Add calendar event_started/event_ended triggers

.github/workflows/builder.yml

@@ -100,7 +100,7 @@ jobs:
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        uses: dawidd6/action-download-artifact@ac66b43f0e6a346234dd65d4d0c8fbb31cb316e5 # v11
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -111,7 +111,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        uses: dawidd6/action-download-artifact@ac66b43f0e6a346234dd65d4d0c8fbb31cb316e5 # v11
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: OHF-Voice/intents-package

.github/workflows/ci.yaml

@@ -40,7 +40,7 @@ env:
   CACHE_VERSION: 2
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2026.2"
+  HA_SHORT_VERSION: "2026.1"
   DEFAULT_PYTHON: "3.13.11"
   ALL_PYTHON_VERSIONS: "['3.13.11', '3.14.2']"
   # 10.3 is the oldest supported version

.gitignore

@@ -92,7 +92,6 @@ pip-selfcheck.json
 venv
 .venv
 Pipfile*
-uv.lock
 share/*
 /Scripts/
 

CODEOWNERS

@@ -516,8 +516,6 @@ build.json @home-assistant/supervisor
 /tests/components/fireservicerota/ @cyberjunky
 /homeassistant/components/firmata/ @DaAwesomeP
 /tests/components/firmata/ @DaAwesomeP
-/homeassistant/components/fish_audio/ @noambav
-/tests/components/fish_audio/ @noambav
 /homeassistant/components/fitbit/ @allenporter
 /tests/components/fitbit/ @allenporter
 /homeassistant/components/fivem/ @Sander0542
@@ -532,8 +530,6 @@ build.json @home-assistant/supervisor
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
-/homeassistant/components/fluss/ @fluss
-/tests/components/fluss/ @fluss
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck
@@ -1699,8 +1695,8 @@ build.json @home-assistant/supervisor
 /tests/components/trafikverket_train/ @gjohansson-ST
 /homeassistant/components/trafikverket_weatherstation/ @gjohansson-ST
 /tests/components/trafikverket_weatherstation/ @gjohansson-ST
-/homeassistant/components/transmission/ @engrbm87 @JPHutchins @andrew-codechimp
-/tests/components/transmission/ @engrbm87 @JPHutchins @andrew-codechimp
+/homeassistant/components/transmission/ @engrbm87 @JPHutchins
+/tests/components/transmission/ @engrbm87 @JPHutchins
 /homeassistant/components/trend/ @jpbede
 /tests/components/trend/ @jpbede
 /homeassistant/components/triggercmd/ @rvmey

homeassistant/components/accuweather/manifest.json

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

homeassistant/components/actron_air/climate.py

@@ -15,10 +15,12 @@ from homeassistant.components.climate import (
 )
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
+from .const import DOMAIN
 from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-from .entity import ActronAirAcEntity, ActronAirZoneEntity
 
 PARALLEL_UPDATES = 0
 
@@ -54,7 +56,8 @@ async def async_setup_entry(
 
     for coordinator in system_coordinators.values():
         status = coordinator.data
-        entities.append(ActronSystemClimate(coordinator))
+        name = status.ac_system.system_name
+        entities.append(ActronSystemClimate(coordinator, name))
 
         entities.extend(
             ActronZoneClimate(coordinator, zone)
@@ -65,9 +68,10 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class ActronAirClimateEntity(ClimateEntity):
+class BaseClimateEntity(CoordinatorEntity[ActronAirSystemCoordinator], ClimateEntity):
     """Base class for Actron Air climate entities."""
 
+    _attr_has_entity_name = True
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_supported_features = (
         ClimateEntityFeature.TARGET_TEMPERATURE
@@ -79,17 +83,43 @@ class ActronAirClimateEntity(ClimateEntity):
     _attr_fan_modes = list(FAN_MODE_MAPPING_ACTRONAIR_TO_HA.values())
     _attr_hvac_modes = list(HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.values())
 
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        name: str,
+    ) -> None:
+        """Initialize an Actron Air unit."""
+        super().__init__(coordinator)
+        self._serial_number = coordinator.serial_number
 
-class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
+
+class ActronSystemClimate(BaseClimateEntity):
     """Representation of the Actron Air system."""
 
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.FAN_MODE
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
+    )
+
     def __init__(
         self,
         coordinator: ActronAirSystemCoordinator,
+        name: str,
     ) -> None:
         """Initialize an Actron Air unit."""
-        super().__init__(coordinator)
-        self._attr_unique_id = self._serial_number
+        super().__init__(coordinator, name)
+        serial_number = coordinator.serial_number
+        self._attr_unique_id = serial_number
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, serial_number)},
+            name=self._status.ac_system.system_name,
+            manufacturer="Actron Air",
+            model_id=self._status.ac_system.master_wc_model,
+            sw_version=self._status.ac_system.master_wc_firmware_version,
+            serial_number=serial_number,
+        )
 
     @property
     def min_temp(self) -> float:
@@ -138,7 +168,7 @@ class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
 
     async def async_set_fan_mode(self, fan_mode: str) -> None:
         """Set a new fan mode."""
-        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode)
+        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode.lower())
         await self._status.user_aircon_settings.set_fan_mode(api_fan_mode)
 
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
@@ -152,7 +182,7 @@ class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
         await self._status.user_aircon_settings.set_temperature(temperature=temp)
 
 
-class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
+class ActronZoneClimate(BaseClimateEntity):
     """Representation of a zone within the Actron Air system."""
 
     _attr_supported_features = (
@@ -167,8 +197,18 @@ class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
         zone: ActronAirZone,
     ) -> None:
         """Initialize an Actron Air unit."""
-        super().__init__(coordinator, zone)
-        self._attr_unique_id: str = self._zone_identifier
+        super().__init__(coordinator, zone.title)
+        serial_number = coordinator.serial_number
+        self._zone_id: int = zone.zone_id
+        self._attr_unique_id: str = f"{serial_number}_zone_{zone.zone_id}"
+        self._attr_device_info: DeviceInfo = DeviceInfo(
+            identifiers={(DOMAIN, self._attr_unique_id)},
+            name=zone.title,
+            manufacturer="Actron Air",
+            model="Zone",
+            suggested_area=zone.title,
+            via_device=(DOMAIN, serial_number),
+        )
 
     @property
     def min_temp(self) -> float:
@@ -216,4 +256,4 @@ class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set the temperature."""
-        await self._zone.set_temperature(temperature=kwargs.get(ATTR_TEMPERATURE))
+        await self._zone.set_temperature(temperature=kwargs["temperature"])

homeassistant/components/actron_air/coordinator.py

@@ -8,7 +8,6 @@ from datetime import timedelta
 from actron_neo_api import (
     ActronAirACSystem,
     ActronAirAPI,
-    ActronAirAPIError,
     ActronAirAuthError,
     ActronAirStatus,
 )
@@ -16,7 +15,7 @@ from actron_neo_api import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util import dt as dt_util
 
 from .const import _LOGGER, DOMAIN
@@ -71,12 +70,6 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
                 translation_domain=DOMAIN,
                 translation_key="auth_error",
             ) from err
-        except ActronAirAPIError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="update_error",
-                translation_placeholders={"error": repr(err)},
-            ) from err
 
         self.status = self.api.state_manager.get_status(self.serial_number)
         self.last_seen = dt_util.utcnow()

homeassistant/components/actron_air/entity.py

@@ -1,63 +0,0 @@
-"""Base entity classes for Actron Air integration."""
-
-from actron_neo_api import ActronAirZone
-
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import ActronAirSystemCoordinator
-
-
-class ActronAirEntity(CoordinatorEntity[ActronAirSystemCoordinator]):
-    """Base class for Actron Air entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: ActronAirSystemCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._serial_number = coordinator.serial_number
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        return not self.coordinator.is_device_stale()
-
-
-class ActronAirAcEntity(ActronAirEntity):
-    """Base class for Actron Air entities."""
-
-    def __init__(self, coordinator: ActronAirSystemCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, self._serial_number)},
-            name=coordinator.data.ac_system.system_name,
-            manufacturer="Actron Air",
-            model_id=coordinator.data.ac_system.master_wc_model,
-            sw_version=coordinator.data.ac_system.master_wc_firmware_version,
-            serial_number=self._serial_number,
-        )
-
-
-class ActronAirZoneEntity(ActronAirEntity):
-    """Base class for Actron Air zone entities."""
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-        zone: ActronAirZone,
-    ) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._zone_id: int = zone.zone_id
-        self._zone_identifier = f"{self._serial_number}_zone_{zone.zone_id}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, self._zone_identifier)},
-            name=zone.title,
-            manufacturer="Actron Air",
-            model="Zone",
-            suggested_area=zone.title,
-            via_device=(DOMAIN, self._serial_number),
-        )

homeassistant/components/actron_air/strings.json

@@ -51,9 +51,6 @@
   "exceptions": {
     "auth_error": {
       "message": "Authentication failed, please reauthenticate"
-    },
-    "update_error": {
-      "message": "An error occurred while retrieving data from the Actron Air API: {error}"
     }
   }
 }

homeassistant/components/actron_air/switch.py

@@ -7,10 +7,12 @@ from typing import Any
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
+from .const import DOMAIN
 from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-from .entity import ActronAirAcEntity
 
 PARALLEL_UPDATES = 0
 
@@ -72,9 +74,10 @@ async def async_setup_entry(
     )
 
 
-class ActronAirSwitch(ActronAirAcEntity, SwitchEntity):
+class ActronAirSwitch(CoordinatorEntity[ActronAirSystemCoordinator], SwitchEntity):
     """Actron Air switch."""
 
+    _attr_has_entity_name = True
     _attr_entity_category = EntityCategory.CONFIG
     entity_description: ActronAirSwitchEntityDescription
 
@@ -87,6 +90,11 @@ class ActronAirSwitch(ActronAirAcEntity, SwitchEntity):
         super().__init__(coordinator)
         self.entity_description = description
         self._attr_unique_id = f"{coordinator.serial_number}_{description.key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, coordinator.serial_number)},
+            manufacturer="Actron Air",
+            name=coordinator.data.ac_system.system_name,
+        )
 
     @property
     def is_on(self) -> bool:

homeassistant/components/adax/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/adax",
   "iot_class": "local_polling",
   "loggers": ["adax", "adax_local"],
-  "requirements": ["adax==0.4.0", "Adax-local==0.3.0"]
+  "requirements": ["adax==0.4.0", "Adax-local==0.2.0"]
 }

homeassistant/components/airobot/__init__.py

@@ -7,7 +7,7 @@ from homeassistant.core import HomeAssistant
 
 from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
 
-PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.NUMBER, Platform.SENSOR]
+PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:

homeassistant/components/airobot/config_flow.py

@@ -175,42 +175,6 @@ class AirobotConfigFlow(BaseConfigFlow, domain=DOMAIN):
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
 
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration of the integration."""
-        errors: dict[str, str] = {}
-        reconfigure_entry = self._get_reconfigure_entry()
-
-        if user_input is not None:
-            try:
-                info = await validate_input(self.hass, user_input)
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                # Verify the device ID matches the existing config entry
-                await self.async_set_unique_id(info.device_id)
-                self._abort_if_unique_id_mismatch(reason="wrong_device")
-
-                return self.async_update_reload_and_abort(
-                    reconfigure_entry,
-                    data_updates=user_input,
-                    title=info.title,
-                )
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=self.add_suggested_values_to_schema(
-                STEP_USER_DATA_SCHEMA, reconfigure_entry.data
-            ),
-            errors=errors,
-        )
-
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:

homeassistant/components/airobot/icons.json

@@ -1,9 +0,0 @@
-{
-  "entity": {
-    "number": {
-      "hysteresis_band": {
-        "default": "mdi:delta"
-      }
-    }
-  }
-}

homeassistant/components/airobot/number.py

@@ -1,99 +0,0 @@
-"""Number platform for Airobot thermostat."""
-
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
-
-from pyairobotrest.const import HYSTERESIS_BAND_MAX, HYSTERESIS_BAND_MIN
-from pyairobotrest.exceptions import AirobotError
-
-from homeassistant.components.number import (
-    NumberDeviceClass,
-    NumberEntity,
-    NumberEntityDescription,
-)
-from homeassistant.const import EntityCategory, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import AirobotConfigEntry
-from .const import DOMAIN
-from .coordinator import AirobotDataUpdateCoordinator
-from .entity import AirobotEntity
-
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class AirobotNumberEntityDescription(NumberEntityDescription):
-    """Describes Airobot number entity."""
-
-    value_fn: Callable[[AirobotDataUpdateCoordinator], float]
-    set_value_fn: Callable[[AirobotDataUpdateCoordinator, float], Awaitable[None]]
-
-
-NUMBERS: tuple[AirobotNumberEntityDescription, ...] = (
-    AirobotNumberEntityDescription(
-        key="hysteresis_band",
-        translation_key="hysteresis_band",
-        device_class=NumberDeviceClass.TEMPERATURE,
-        entity_category=EntityCategory.CONFIG,
-        entity_registry_enabled_default=False,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        native_min_value=HYSTERESIS_BAND_MIN / 10.0,
-        native_max_value=HYSTERESIS_BAND_MAX / 10.0,
-        native_step=0.1,
-        value_fn=lambda coordinator: coordinator.data.settings.hysteresis_band,
-        set_value_fn=lambda coordinator, value: coordinator.client.set_hysteresis_band(
-            value
-        ),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AirobotConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Airobot number platform."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        AirobotNumber(coordinator, description) for description in NUMBERS
-    )
-
-
-class AirobotNumber(AirobotEntity, NumberEntity):
-    """Representation of an Airobot number entity."""
-
-    entity_description: AirobotNumberEntityDescription
-
-    def __init__(
-        self,
-        coordinator: AirobotDataUpdateCoordinator,
-        description: AirobotNumberEntityDescription,
-    ) -> None:
-        """Initialize the number entity."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.data.status.device_id}_{description.key}"
-
-    @property
-    def native_value(self) -> float:
-        """Return the current value."""
-        return self.entity_description.value_fn(self.coordinator)
-
-    async def async_set_native_value(self, value: float) -> None:
-        """Set the value."""
-        try:
-            await self.entity_description.set_value_fn(self.coordinator, value)
-        except AirobotError as err:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="set_value_failed",
-                translation_placeholders={"error": str(err)},
-            ) from err
-        else:
-            await self.coordinator.async_request_refresh()

homeassistant/components/airobot/quality_scale.yaml

@@ -48,7 +48,7 @@ rules:
   docs-supported-devices: done
   docs-supported-functions: done
   docs-troubleshooting: done
-  docs-use-cases: done
+  docs-use-cases: todo
   dynamic-devices:
     status: exempt
     comment: Single device integration, no dynamic device discovery needed.
@@ -57,8 +57,8 @@ rules:
   entity-disabled-by-default: done
   entity-translations: done
   exception-translations: done
-  icon-translations: done
-  reconfiguration-flow: done
+  icon-translations: todo
+  reconfiguration-flow: todo
   repair-issues:
     status: exempt
     comment: This integration doesn't have any cases where raising an issue is needed.

homeassistant/components/airobot/strings.json

@@ -2,9 +2,7 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
-      "wrong_device": "Device ID does not match the existing configuration. Please use the correct device credentials."
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -30,19 +28,6 @@
         },
         "description": "The authentication for Airobot thermostat at {host} (Device ID: {username}) has expired. Please enter the password to reauthenticate. Find the password in the thermostat settings menu under Connectivity → Mobile app."
       },
-      "reconfigure": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]",
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "Device ID"
-        },
-        "data_description": {
-          "host": "[%key:component::airobot::config::step::user::data_description::host%]",
-          "password": "[%key:component::airobot::config::step::user::data_description::password%]",
-          "username": "[%key:component::airobot::config::step::user::data_description::username%]"
-        },
-        "description": "Update your Airobot thermostat connection details. Note: The Device ID must remain the same as the original configuration."
-      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
@@ -59,11 +44,6 @@
     }
   },
   "entity": {
-    "number": {
-      "hysteresis_band": {
-        "name": "Hysteresis band"
-      }
-    },
     "sensor": {
       "air_temperature": {
         "name": "Air temperature"
@@ -94,9 +74,6 @@
     },
     "set_temperature_failed": {
       "message": "Failed to set temperature to {temperature}."
-    },
-    "set_value_failed": {
-      "message": "Failed to set value: {error}"
     }
   }
 }

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/anglian_water/config_flow.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from aiohttp import CookieJar
 from pyanglianwater import AnglianWater
@@ -30,11 +30,14 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_PASSWORD): selector.TextSelector(
             selector.TextSelectorConfig(type=selector.TextSelectorType.PASSWORD)
         ),
+        vol.Required(CONF_ACCOUNT_NUMBER): selector.TextSelector(),
     }
 )
 
 
-async def validate_credentials(auth: MSOB2CAuth) -> str | MSOB2CAuth:
+async def validate_credentials(
+    auth: MSOB2CAuth, account_number: str
+) -> str | MSOB2CAuth:
     """Validate the provided credentials."""
     try:
         await auth.send_login_request()
@@ -43,33 +46,6 @@ async def validate_credentials(auth: MSOB2CAuth) -> str | MSOB2CAuth:
     except Exception:
         _LOGGER.exception("Unexpected exception")
         return "unknown"
-    return auth
-
-
-def humanize_account_data(account: dict) -> str:
-    """Convert an account data into a human-readable format."""
-    if account["address"]["company_name"] != "":
-        return f"{account['account_number']} - {account['address']['company_name']}"
-    if account["address"]["building_name"] != "":
-        return f"{account['account_number']} - {account['address']['building_name']}"
-    return f"{account['account_number']} - {account['address']['postcode']}"
-
-
-async def get_accounts(auth: MSOB2CAuth) -> list[selector.SelectOptionDict]:
-    """Retrieve the list of accounts associated with the authenticated user."""
-    _aw = AnglianWater(authenticator=auth)
-    accounts = await _aw.api.get_associated_accounts()
-    return [
-        selector.SelectOptionDict(
-            value=str(account["account_number"]),
-            label=humanize_account_data(account),
-        )
-        for account in accounts["result"]["active"]
-    ]
-
-
-async def validate_account(auth: MSOB2CAuth, account_number: str) -> str | MSOB2CAuth:
-    """Validate the provided account number."""
     _aw = AnglianWater(authenticator=auth)
     try:
         await _aw.validate_smart_meter(account_number)
@@ -81,91 +57,36 @@ async def validate_account(auth: MSOB2CAuth, account_number: str) -> str | MSOB2
 class AnglianWaterConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Anglian Water."""
 
-    def __init__(self) -> None:
-        """Initialize the config flow."""
-        self.authenticator: MSOB2CAuth | None = None
-        self.accounts: list[selector.SelectOptionDict] = []
-        self.user_input: dict[str, Any] | None = None
-
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
         errors: dict[str, str] = {}
         if user_input is not None:
-            self.authenticator = MSOB2CAuth(
-                username=user_input[CONF_USERNAME],
-                password=user_input[CONF_PASSWORD],
-                session=async_create_clientsession(
-                    self.hass,
-                    cookie_jar=CookieJar(quote_cookie=False),
+            validation_response = await validate_credentials(
+                MSOB2CAuth(
+                    username=user_input[CONF_USERNAME],
+                    password=user_input[CONF_PASSWORD],
+                    session=async_create_clientsession(
+                        self.hass,
+                        cookie_jar=CookieJar(quote_cookie=False),
+                    ),
                 ),
+                user_input[CONF_ACCOUNT_NUMBER],
             )
-            validation_response = await validate_credentials(self.authenticator)
             if isinstance(validation_response, str):
                 errors["base"] = validation_response
             else:
-                self.accounts = await get_accounts(self.authenticator)
-                if len(self.accounts) > 1:
-                    self.user_input = user_input
-                    return await self.async_step_select_account()
-                account_number = self.accounts[0]["value"]
-                self.user_input = user_input
-                return await self.async_step_complete(
-                    {
-                        CONF_ACCOUNT_NUMBER: account_number,
-                    }
+                await self.async_set_unique_id(user_input[CONF_ACCOUNT_NUMBER])
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=user_input[CONF_ACCOUNT_NUMBER],
+                    data={
+                        **user_input,
+                        CONF_ACCESS_TOKEN: validation_response.refresh_token,
+                    },
                 )
 
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
-
-    async def async_step_select_account(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the account selection step."""
-        errors = {}
-        if user_input is not None:
-            if TYPE_CHECKING:
-                assert self.authenticator
-            validation_result = await validate_account(
-                self.authenticator,
-                user_input[CONF_ACCOUNT_NUMBER],
-            )
-            if isinstance(validation_result, str):
-                errors["base"] = validation_result
-            else:
-                return await self.async_step_complete(user_input)
-        return self.async_show_form(
-            step_id="select_account",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_ACCOUNT_NUMBER): selector.SelectSelector(
-                        selector.SelectSelectorConfig(
-                            options=self.accounts,
-                            multiple=False,
-                            mode=selector.SelectSelectorMode.DROPDOWN,
-                        )
-                    )
-                }
-            ),
-            errors=errors,
-        )
-
-    async def async_step_complete(self, user_input: dict[str, Any]) -> ConfigFlowResult:
-        """Handle the final configuration step."""
-        await self.async_set_unique_id(user_input[CONF_ACCOUNT_NUMBER])
-        self._abort_if_unique_id_configured()
-        if TYPE_CHECKING:
-            assert self.authenticator
-            assert self.user_input
-        config_entry_data = {
-            **self.user_input,
-            CONF_ACCOUNT_NUMBER: user_input[CONF_ACCOUNT_NUMBER],
-            CONF_ACCESS_TOKEN: self.authenticator.refresh_token,
-        }
-        return self.async_create_entry(
-            title=user_input[CONF_ACCOUNT_NUMBER],
-            data=config_entry_data,
-        )

homeassistant/components/anglian_water/strings.json

@@ -10,21 +10,14 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
-      "select_account": {
-        "data": {
-          "account_number": "Billing account number"
-        },
-        "data_description": {
-          "account_number": "Select the billing account you wish to use."
-        },
-        "description": "Multiple active billing accounts were found with your credentials. Please select the account you wish to use. If this is unexpected, contact Anglian Water to confirm your active accounts."
-      },
       "user": {
         "data": {
+          "account_number": "Billing Account Number",
           "password": "[%key:common::config_flow::data::password%]",
           "username": "[%key:common::config_flow::data::username%]"
         },
         "data_description": {
+          "account_number": "Your account number found on your latest bill.",
           "password": "Your password",
           "username": "Username or email used to log in to the Anglian Water website."
         },

homeassistant/components/axis/manifest.json

@@ -29,7 +29,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["axis"],
-  "requirements": ["axis==66"],
+  "requirements": ["axis==65"],
   "ssdp": [
     {
       "manufacturer": "AXIS"

homeassistant/components/azure_data_explorer/client.py

@@ -80,7 +80,7 @@ class AzureDataExplorerClient:
     def test_connection(self) -> None:
         """Test connection, will throw Exception if it cannot connect."""
 
-        query = f"['{self._table}'] | take 1"
+        query = f"{self._table} | take 1"
 
         self.query_client.execute_query(self._database, query)
 

homeassistant/components/azure_data_explorer/config_flow.py

@@ -45,7 +45,7 @@ class ADXConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    async def validate_input(self, data: dict[str, Any]) -> dict[str, str]:
+    async def validate_input(self, data: dict[str, Any]) -> dict[str, Any] | None:
         """Validate the user input allows us to connect.
 
         Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
@@ -54,40 +54,36 @@ class ADXConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
         try:
             await self.hass.async_add_executor_job(client.test_connection)
-        except KustoAuthenticationError as err:
-            _LOGGER.error("Authentication failed: %s", err)
+
+        except KustoAuthenticationError as exp:
+            _LOGGER.error(exp)
             return {"base": "invalid_auth"}
-        except KustoServiceError as err:
-            _LOGGER.error("Could not connect: %s", err)
+
+        except KustoServiceError as exp:
+            _LOGGER.error(exp)
             return {"base": "cannot_connect"}
 
-        return {}
+        return None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
 
-        errors: dict[str, str] = {}
-        data_schema = STEP_USER_DATA_SCHEMA
-
-        if user_input is not None:
-            errors = await self.validate_input(user_input)
+        errors: dict = {}
+        if user_input:
+            errors = await self.validate_input(user_input)  # type: ignore[assignment]
             if not errors:
                 return self.async_create_entry(
                     data=user_input,
-                    title=f"{user_input[CONF_ADX_CLUSTER_INGEST_URI].replace('https://', '')} / {user_input[CONF_ADX_DATABASE_NAME]} ({user_input[CONF_ADX_TABLE_NAME]})",
+                    title=user_input[CONF_ADX_CLUSTER_INGEST_URI].replace(
+                        "https://", ""
+                    ),
                     options=DEFAULT_OPTIONS,
                 )
-
-            # Keep previously entered values when we re-show the form after an error.
-            data_schema = self.add_suggested_values_to_schema(
-                STEP_USER_DATA_SCHEMA, user_input
-            )
-
         return self.async_show_form(
             step_id="user",
-            data_schema=data_schema,
+            data_schema=STEP_USER_DATA_SCHEMA,
             errors=errors,
             last_step=True,
         )

homeassistant/components/azure_data_explorer/strings.json

@@ -20,7 +20,6 @@
           "use_queued_ingestion": "Use queued ingestion"
         },
         "data_description": {
-          "authority_id": "In Azure portal this is also known as Directory (tenant) ID",
           "cluster_ingest_uri": "Ingestion URI of the cluster",
           "use_queued_ingestion": "Must be enabled when using ADX free cluster"
         },

homeassistant/components/backblaze_b2/__init__.py

@@ -6,15 +6,13 @@ from datetime import timedelta
 import logging
 from typing import Any
 
-from b2sdk.v2 import Bucket, exception
+from b2sdk.v2 import B2Api, Bucket, InMemoryAccountInfo, exception
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.event import async_track_time_interval
 
-# Import from b2_client to ensure timeout configuration is applied
-from .b2_client import B2Api, InMemoryAccountInfo
 from .const import (
     BACKBLAZE_REALM,
     CONF_APPLICATION_KEY,
@@ -74,11 +72,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: BackblazeConfigEntry) ->
             translation_domain=DOMAIN,
             translation_key="invalid_bucket_name",
         ) from err
-    except (
-        exception.B2ConnectionError,
-        exception.B2RequestTimeout,
-        exception.ConnectionReset,
-    ) as err:
+    except exception.ConnectionReset as err:
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN,
             translation_key="cannot_connect",

homeassistant/components/backblaze_b2/b2_client.py

@@ -1,39 +0,0 @@
-"""Backblaze B2 client with extended timeouts.
-
-The b2sdk library uses class-level timeout attributes. To avoid modifying
-global library state, we subclass the relevant classes to provide extended
-timeouts suitable for backup operations involving large files.
-"""
-
-from b2sdk.v2 import B2Api as BaseB2Api, InMemoryAccountInfo
-from b2sdk.v2.b2http import B2Http as BaseB2Http
-from b2sdk.v2.session import B2Session as BaseB2Session
-
-# Extended timeouts for Home Assistant backup operations
-# Default CONNECTION_TIMEOUT is 46 seconds, which can be too short for slow connections
-CONNECTION_TIMEOUT = 120  # 2 minutes
-
-# Default TIMEOUT_FOR_UPLOAD is 128 seconds, which is too short for large backups
-TIMEOUT_FOR_UPLOAD = 43200  # 12 hours
-
-
-class B2Http(BaseB2Http):  # type: ignore[misc]
-    """B2Http with extended timeouts for backup operations."""
-
-    CONNECTION_TIMEOUT = CONNECTION_TIMEOUT
-    TIMEOUT_FOR_UPLOAD = TIMEOUT_FOR_UPLOAD
-
-
-class B2Session(BaseB2Session):  # type: ignore[misc]
-    """B2Session using custom B2Http with extended timeouts."""
-
-    B2HTTP_CLASS = B2Http
-
-
-class B2Api(BaseB2Api):  # type: ignore[misc]
-    """B2Api using custom session with extended timeouts."""
-
-    SESSION_CLASS = B2Session
-
-
-__all__ = ["B2Api", "InMemoryAccountInfo"]

homeassistant/components/backblaze_b2/config_flow.py

@@ -6,7 +6,7 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
-from b2sdk.v2 import exception
+from b2sdk.v2 import B2Api, InMemoryAccountInfo, exception
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
@@ -17,8 +17,6 @@ from homeassistant.helpers.selector import (
     TextSelectorType,
 )
 
-# Import from b2_client to ensure timeout configuration is applied
-from .b2_client import B2Api, InMemoryAccountInfo
 from .const import (
     BACKBLAZE_REALM,
     CONF_APPLICATION_KEY,
@@ -174,12 +172,8 @@ class BackblazeConfigFlow(ConfigFlow, domain=DOMAIN):
                 "Backblaze B2 bucket '%s' does not exist", user_input[CONF_BUCKET]
             )
             errors[CONF_BUCKET] = "invalid_bucket_name"
-        except (
-            exception.B2ConnectionError,
-            exception.B2RequestTimeout,
-            exception.ConnectionReset,
-        ) as err:
-            _LOGGER.error("Failed to connect to Backblaze B2: %s", err)
+        except exception.ConnectionReset:
+            _LOGGER.error("Failed to connect to Backblaze B2. Connection reset")
             errors["base"] = "cannot_connect"
         except exception.MissingAccountData:
             # This generally indicates an issue with how InMemoryAccountInfo is used

homeassistant/components/backblaze_b2/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_push",
   "loggers": ["b2sdk"],
   "quality_scale": "bronze",
-  "requirements": ["b2sdk==2.10.1"]
+  "requirements": ["b2sdk==2.8.1"]
 }

homeassistant/components/blackbird/manifest.json

@@ -2,6 +2,7 @@
   "domain": "blackbird",
   "name": "Monoprice Blackbird Matrix Switch",
   "codeowners": [],
+  "disabled": "This integration is disabled because it references pyserial-asyncio, which does blocking I/O in the asyncio loop and is not maintained.",
   "documentation": "https://www.home-assistant.io/integrations/blackbird",
   "iot_class": "local_polling",
   "loggers": ["pyblackbird"],

homeassistant/components/bluesound/__init__.py

@@ -2,25 +2,16 @@
 
 from pyblu import Player
 from pyblu.errors import PlayerUnreachableError
-import voluptuous as vol
 
-from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv, service
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.typing import ConfigType
 
-from .const import (
-    ATTR_MASTER,
-    DOMAIN,
-    SERVICE_CLEAR_TIMER,
-    SERVICE_JOIN,
-    SERVICE_SET_TIMER,
-    SERVICE_UNJOIN,
-)
+from .const import DOMAIN
 from .coordinator import (
     BluesoundConfigEntry,
     BluesoundCoordinator,
@@ -37,38 +28,6 @@ PLATFORMS = [
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Bluesound."""
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_SET_TIMER,
-        entity_domain=MEDIA_PLAYER_DOMAIN,
-        schema=None,
-        func="async_increase_timer",
-    )
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_CLEAR_TIMER,
-        entity_domain=MEDIA_PLAYER_DOMAIN,
-        schema=None,
-        func="async_clear_timer",
-    )
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_JOIN,
-        entity_domain=MEDIA_PLAYER_DOMAIN,
-        schema={vol.Required(ATTR_MASTER): cv.entity_id},
-        func="async_bluesound_join",
-    )
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        SERVICE_UNJOIN,
-        entity_domain=MEDIA_PLAYER_DOMAIN,
-        schema=None,
-        func="async_bluesound_unjoin",
-    )
     return True
 
 

homeassistant/components/bluesound/const.py

@@ -4,8 +4,3 @@ DOMAIN = "bluesound"
 INTEGRATION_TITLE = "Bluesound"
 ATTR_BLUESOUND_GROUP = "bluesound_group"
 ATTR_MASTER = "master"
-
-SERVICE_CLEAR_TIMER = "clear_sleep_timer"
-SERVICE_JOIN = "join"
-SERVICE_SET_TIMER = "set_sleep_timer"
-SERVICE_UNJOIN = "unjoin"

homeassistant/components/bluesound/media_player.py

@@ -8,6 +8,7 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from pyblu import Input, Player, Preset, Status, SyncStatus
+import voluptuous as vol
 
 from homeassistant.components import media_source
 from homeassistant.components.media_player import (
@@ -21,7 +22,11 @@ from homeassistant.components.media_player import (
 from homeassistant.const import CONF_HOST, CONF_PORT
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers import entity_registry as er, issue_registry as ir
+from homeassistant.helpers import (
+    config_validation as cv,
+    entity_platform,
+    issue_registry as ir,
+)
 from homeassistant.helpers.device_registry import (
     CONNECTION_NETWORK_MAC,
     DeviceInfo,
@@ -35,22 +40,9 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.util import dt as dt_util, slugify
 
-from .const import (
-    ATTR_BLUESOUND_GROUP,
-    ATTR_MASTER,
-    DOMAIN,
-    SERVICE_CLEAR_TIMER,
-    SERVICE_JOIN,
-    SERVICE_SET_TIMER,
-    SERVICE_UNJOIN,
-)
+from .const import ATTR_BLUESOUND_GROUP, ATTR_MASTER, DOMAIN
 from .coordinator import BluesoundCoordinator
-from .utils import (
-    dispatcher_join_signal,
-    dispatcher_unjoin_signal,
-    format_unique_id,
-    id_to_paired_player,
-)
+from .utils import dispatcher_join_signal, dispatcher_unjoin_signal, format_unique_id
 
 if TYPE_CHECKING:
     from . import BluesoundConfigEntry
@@ -62,6 +54,11 @@ SCAN_INTERVAL = timedelta(minutes=15)
 DATA_BLUESOUND = DOMAIN
 DEFAULT_PORT = 11000
 
+SERVICE_CLEAR_TIMER = "clear_sleep_timer"
+SERVICE_JOIN = "join"
+SERVICE_SET_TIMER = "set_sleep_timer"
+SERVICE_UNJOIN = "unjoin"
+
 POLL_TIMEOUT = 120
 
 
@@ -78,6 +75,18 @@ async def async_setup_entry(
         config_entry.runtime_data.player,
     )
 
+    platform = entity_platform.async_get_current_platform()
+    platform.async_register_entity_service(
+        SERVICE_SET_TIMER, None, "async_increase_timer"
+    )
+    platform.async_register_entity_service(
+        SERVICE_CLEAR_TIMER, None, "async_clear_timer"
+    )
+    platform.async_register_entity_service(
+        SERVICE_JOIN, {vol.Required(ATTR_MASTER): cv.entity_id}, "async_join"
+    )
+    platform.async_register_entity_service(SERVICE_UNJOIN, None, "async_unjoin")
+
     async_add_entities([bluesound_player], update_before_add=True)
 
 
@@ -111,7 +120,6 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
         self._presets: list[Preset] = coordinator.data.presets
         self._group_name: str | None = None
         self._group_list: list[str] = []
-        self._group_members: list[str] | None = None
         self._bluesound_device_name = sync_status.name
         self._player = player
         self._last_status_update = dt_util.utcnow()
@@ -172,7 +180,6 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
         self._last_status_update = dt_util.utcnow()
 
         self._group_list = self.rebuild_bluesound_group()
-        self._group_members = self.rebuild_group_members()
 
         self.async_write_ha_state()
 
@@ -358,13 +365,11 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
                 MediaPlayerEntityFeature.VOLUME_STEP
                 | MediaPlayerEntityFeature.VOLUME_SET
                 | MediaPlayerEntityFeature.VOLUME_MUTE
-                | MediaPlayerEntityFeature.GROUPING
             )
 
         supported = (
             MediaPlayerEntityFeature.CLEAR_PLAYLIST
             | MediaPlayerEntityFeature.BROWSE_MEDIA
-            | MediaPlayerEntityFeature.GROUPING
         )
 
         if not self._status.indexing:
@@ -416,57 +421,8 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
 
         return shuffle
 
-    @property
-    def group_members(self) -> list[str] | None:
-        """Get list of group members. Leader is always first."""
-        return self._group_members
-
-    async def async_join_players(self, group_members: list[str]) -> None:
-        """Join `group_members` as a player group with the current player."""
-        if self.entity_id in group_members:
-            raise ServiceValidationError("Cannot join player to itself")
-
-        entity_ids_with_sync_status = self._entity_ids_with_sync_status()
-
-        paired_players = []
-        for group_member in group_members:
-            sync_status = entity_ids_with_sync_status.get(group_member)
-            if sync_status is None:
-                continue
-            paired_player = id_to_paired_player(sync_status.id)
-            if paired_player:
-                paired_players.append(paired_player)
-
-        if paired_players:
-            await self._player.add_followers(paired_players)
-
-    async def async_unjoin_player(self) -> None:
-        """Remove this player from any group."""
-        if self._sync_status.leader is not None:
-            leader_id = f"{self._sync_status.leader.ip}:{self._sync_status.leader.port}"
-            async_dispatcher_send(
-                self.hass, dispatcher_unjoin_signal(leader_id), self.host, self.port
-            )
-
-        if self._sync_status.followers is not None:
-            await self._player.remove_follower(self.host, self.port)
-
-    async def async_bluesound_join(self, master: str) -> None:
+    async def async_join(self, master: str) -> None:
         """Join the player to a group."""
-        ir.async_create_issue(
-            self.hass,
-            DOMAIN,
-            f"deprecated_service_{SERVICE_JOIN}",
-            is_fixable=False,
-            breaks_in_ha_version="2026.7.0",
-            issue_domain=DOMAIN,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key="deprecated_service_join",
-            translation_placeholders={
-                "name": slugify(self.sync_status.name),
-            },
-        )
-
         if master == self.entity_id:
             raise ServiceValidationError("Cannot join player to itself")
 
@@ -475,23 +431,17 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
             self.hass, dispatcher_join_signal(master), self.host, self.port
         )
 
-    async def async_bluesound_unjoin(self) -> None:
+    async def async_unjoin(self) -> None:
         """Unjoin the player from a group."""
-        ir.async_create_issue(
-            self.hass,
-            DOMAIN,
-            f"deprecated_service_{SERVICE_UNJOIN}",
-            is_fixable=False,
-            breaks_in_ha_version="2026.7.0",
-            issue_domain=DOMAIN,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key="deprecated_service_unjoin",
-            translation_placeholders={
-                "name": slugify(self.sync_status.name),
-            },
-        )
+        if self._sync_status.leader is None:
+            return
 
-        await self.async_unjoin_player()
+        leader_id = f"{self._sync_status.leader.ip}:{self._sync_status.leader.port}"
+
+        _LOGGER.debug("Trying to unjoin player: %s", self.id)
+        async_dispatcher_send(
+            self.hass, dispatcher_unjoin_signal(leader_id), self.host, self.port
+        )
 
     @property
     def extra_state_attributes(self) -> dict[str, Any] | None:
@@ -538,63 +488,6 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
         follower_names.insert(0, leader_sync_status.name)
         return follower_names
 
-    def rebuild_group_members(self) -> list[str] | None:
-        """Get list of group members. Leader is always first."""
-        if self.sync_status.leader is None and self.sync_status.followers is None:
-            return None
-
-        entity_ids_with_sync_status = self._entity_ids_with_sync_status()
-
-        leader_entity_id = None
-        followers = None
-        if self.sync_status.followers is not None:
-            leader_entity_id = self.entity_id
-            followers = self.sync_status.followers
-        elif self.sync_status.leader is not None:
-            leader_id = f"{self.sync_status.leader.ip}:{self.sync_status.leader.port}"
-            for entity_id, sync_status in entity_ids_with_sync_status.items():
-                if sync_status.id == leader_id:
-                    leader_entity_id = entity_id
-                    followers = sync_status.followers
-                    break
-
-        if leader_entity_id is None or followers is None:
-            return None
-
-        grouped_entity_ids = [leader_entity_id]
-        for follower in followers:
-            follower_id = f"{follower.ip}:{follower.port}"
-            entity_ids = [
-                entity_id
-                for entity_id, sync_status in entity_ids_with_sync_status.items()
-                if sync_status.id == follower_id
-            ]
-            match entity_ids:
-                case [entity_id]:
-                    grouped_entity_ids.append(entity_id)
-
-        return grouped_entity_ids
-
-    def _entity_ids_with_sync_status(self) -> dict[str, SyncStatus]:
-        result = {}
-
-        entity_registry = er.async_get(self.hass)
-
-        config_entries: list[BluesoundConfigEntry] = (
-            self.hass.config_entries.async_entries(DOMAIN)
-        )
-        for config_entry in config_entries:
-            entity_entries = er.async_entries_for_config_entry(
-                entity_registry, config_entry.entry_id
-            )
-            for entity_entry in entity_entries:
-                if entity_entry.domain == "media_player":
-                    result[entity_entry.entity_id] = (
-                        config_entry.runtime_data.coordinator.data.sync_status
-                    )
-
-        return result
-
     async def async_add_follower(self, host: str, port: int) -> None:
         """Add follower to leader."""
         await self._player.add_follower(host, port)

homeassistant/components/bluesound/strings.json

@@ -41,17 +41,9 @@
       "description": "Use `button.{name}_clear_sleep_timer` instead.\n\nPlease replace this action and adjust your automations and scripts.",
       "title": "Detected use of deprecated action bluesound.clear_sleep_timer"
     },
-    "deprecated_service_join": {
-      "description": "Use the `media_player.join` action instead.\n\nPlease replace this action and adjust your automations and scripts.",
-      "title": "Detected use of deprecated action bluesound.join"
-    },
     "deprecated_service_set_sleep_timer": {
       "description": "Use `button.{name}_set_sleep_timer` instead.\n\nPlease replace this action and adjust your automations and scripts.",
       "title": "Detected use of deprecated action bluesound.set_sleep_timer"
-    },
-    "deprecated_service_unjoin": {
-      "description": "Use the `media_player.unjoin` action instead.\n\nPlease replace this action and adjust your automations and scripts.",
-      "title": "Detected use of deprecated action bluesound.unjoin"
     }
   },
   "services": {

homeassistant/components/bluesound/utils.py

@@ -1,7 +1,5 @@
 """Utility functions for the Bluesound component."""
 
-from pyblu import PairedPlayer
-
 from homeassistant.helpers.device_registry import format_mac
 
 
@@ -21,12 +19,3 @@ def dispatcher_unjoin_signal(leader_id: str) -> str:
     Id is ip_address:port. This can be obtained from sync_status.id.
     """
     return f"bluesound_unjoin_{leader_id}"
-
-
-def id_to_paired_player(id: str) -> PairedPlayer | None:
-    """Try to convert id in format 'ip:port' to PairedPlayer. Returns None if unable to do so."""
-    match id.rsplit(":", 1):
-        case [str() as ip, str() as port] if port.isdigit():
-            return PairedPlayer(ip, int(port))
-        case _:
-            return None

homeassistant/components/bsblan/__init__.py

@@ -27,18 +27,13 @@ from homeassistant.exceptions import (
     ConfigEntryError,
     ConfigEntryNotReady,
 )
-from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.typing import ConfigType
 
 from .const import CONF_PASSKEY, DOMAIN
 from .coordinator import BSBLanFastCoordinator, BSBLanSlowCoordinator
-from .services import async_setup_services
 
 PLATFORMS = [Platform.CLIMATE, Platform.SENSOR, Platform.WATER_HEATER]
 
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-
 type BSBLanConfigEntry = ConfigEntry[BSBLanData]
 
 
@@ -54,12 +49,6 @@ class BSBLanData:
     static: StaticState
 
 
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the BSB-Lan integration."""
-    async_setup_services(hass)
-    return True
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bool:
     """Set up BSB-Lan from a config entry."""
 

homeassistant/components/bsblan/icons.json

@@ -1,7 +0,0 @@
-{
-  "services": {
-    "set_hot_water_schedule": {
-      "service": "mdi:calendar-clock"
-    }
-  }
-}

homeassistant/components/bsblan/services.py

@@ -1,217 +0,0 @@
-"""Support for BSB-Lan services."""
-
-from __future__ import annotations
-
-from datetime import time
-import logging
-from typing import TYPE_CHECKING
-
-from bsblan import BSBLANError, DaySchedule, DHWSchedule, TimeSlot
-
-from homeassistant.config_entries import ConfigEntryState
-from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import device_registry as dr
-
-from .const import DOMAIN
-
-if TYPE_CHECKING:
-    from . import BSBLanConfigEntry
-
-LOGGER = logging.getLogger(__name__)
-
-ATTR_DEVICE_ID = "device_id"
-ATTR_MONDAY_SLOTS = "monday_slots"
-ATTR_TUESDAY_SLOTS = "tuesday_slots"
-ATTR_WEDNESDAY_SLOTS = "wednesday_slots"
-ATTR_THURSDAY_SLOTS = "thursday_slots"
-ATTR_FRIDAY_SLOTS = "friday_slots"
-ATTR_SATURDAY_SLOTS = "saturday_slots"
-ATTR_SUNDAY_SLOTS = "sunday_slots"
-
-# Service name
-SERVICE_SET_HOT_WATER_SCHEDULE = "set_hot_water_schedule"
-
-
-def _parse_time_value(value: time | str) -> time:
-    """Parse a time value from either a time object or string.
-
-    Raises ServiceValidationError if the format is invalid.
-    """
-    if isinstance(value, time):
-        return value
-
-    if isinstance(value, str):
-        try:
-            parts = value.split(":")
-            return time(int(parts[0]), int(parts[1]))
-        except (ValueError, IndexError):
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="invalid_time_format",
-            ) from None
-
-    raise ServiceValidationError(
-        translation_domain=DOMAIN,
-        translation_key="invalid_time_format",
-    )
-
-
-def _convert_time_slots_to_day_schedule(
-    slots: list[dict[str, time]] | None,
-) -> DaySchedule | None:
-    """Convert list of time slot dicts to a DaySchedule object.
-
-    Example: [{"start_time": "06:00", "end_time": "08:00"},
-              {"start_time": "17:00", "end_time": "21:00"}]
-    becomes: DaySchedule with two TimeSlot objects
-
-    None returns None (don't modify this day).
-    Empty list returns DaySchedule with empty slots (clear this day).
-    """
-    if slots is None:
-        return None
-
-    if not slots:
-        return DaySchedule(slots=[])
-
-    time_slots = []
-    for slot in slots:
-        start = slot.get("start_time")
-        end = slot.get("end_time")
-
-        if start and end:
-            start_time = _parse_time_value(start)
-            end_time = _parse_time_value(end)
-
-            # Validate that end time is after start time
-            if end_time <= start_time:
-                raise ServiceValidationError(
-                    translation_domain=DOMAIN,
-                    translation_key="end_time_before_start_time",
-                    translation_placeholders={
-                        "start_time": start_time.strftime("%H:%M"),
-                        "end_time": end_time.strftime("%H:%M"),
-                    },
-                )
-
-            time_slots.append(TimeSlot(start=start_time, end=end_time))
-            LOGGER.debug(
-                "Created time slot: %s-%s",
-                start_time.strftime("%H:%M"),
-                end_time.strftime("%H:%M"),
-            )
-
-    LOGGER.debug("Created DaySchedule with %d slots", len(time_slots))
-    return DaySchedule(slots=time_slots)
-
-
-async def set_hot_water_schedule(service_call: ServiceCall) -> None:
-    """Set hot water heating schedule."""
-    device_id = service_call.data[ATTR_DEVICE_ID]
-
-    # Get the device and config entry
-    device_registry = dr.async_get(service_call.hass)
-    device_entry = device_registry.async_get(device_id)
-
-    if device_entry is None:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="invalid_device_id",
-            translation_placeholders={"device_id": device_id},
-        )
-
-    # Find the config entry for this device
-    matching_entries: list[BSBLanConfigEntry] = [
-        entry
-        for entry in service_call.hass.config_entries.async_entries(DOMAIN)
-        if entry.entry_id in device_entry.config_entries
-    ]
-
-    if not matching_entries:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="no_config_entry_for_device",
-            translation_placeholders={"device_id": device_entry.name or device_id},
-        )
-
-    entry = matching_entries[0]
-
-    # Verify the config entry is loaded
-    if entry.state is not ConfigEntryState.LOADED:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="config_entry_not_loaded",
-            translation_placeholders={"device_name": device_entry.name or device_id},
-        )
-
-    client = entry.runtime_data.client
-
-    # Convert time slots to DaySchedule objects
-    monday = _convert_time_slots_to_day_schedule(
-        service_call.data.get(ATTR_MONDAY_SLOTS)
-    )
-    tuesday = _convert_time_slots_to_day_schedule(
-        service_call.data.get(ATTR_TUESDAY_SLOTS)
-    )
-    wednesday = _convert_time_slots_to_day_schedule(
-        service_call.data.get(ATTR_WEDNESDAY_SLOTS)
-    )
-    thursday = _convert_time_slots_to_day_schedule(
-        service_call.data.get(ATTR_THURSDAY_SLOTS)
-    )
-    friday = _convert_time_slots_to_day_schedule(
-        service_call.data.get(ATTR_FRIDAY_SLOTS)
-    )
-    saturday = _convert_time_slots_to_day_schedule(
-        service_call.data.get(ATTR_SATURDAY_SLOTS)
-    )
-    sunday = _convert_time_slots_to_day_schedule(
-        service_call.data.get(ATTR_SUNDAY_SLOTS)
-    )
-
-    # Create the DHWSchedule object
-    dhw_schedule = DHWSchedule(
-        monday=monday,
-        tuesday=tuesday,
-        wednesday=wednesday,
-        thursday=thursday,
-        friday=friday,
-        saturday=saturday,
-        sunday=sunday,
-    )
-
-    LOGGER.debug(
-        "Setting hot water schedule - Monday: %s, Tuesday: %s, Wednesday: %s, "
-        "Thursday: %s, Friday: %s, Saturday: %s, Sunday: %s",
-        monday,
-        tuesday,
-        wednesday,
-        thursday,
-        friday,
-        saturday,
-        sunday,
-    )
-
-    try:
-        # Call the BSB-Lan API to set the schedule
-        await client.set_hot_water_schedule(dhw_schedule)
-    except BSBLANError as err:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="set_schedule_failed",
-            translation_placeholders={"error": str(err)},
-        ) from err
-
-    # Refresh the slow coordinator to get the updated schedule
-    await entry.runtime_data.slow_coordinator.async_request_refresh()
-
-
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
-    """Register the BSB-Lan services."""
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_SET_HOT_WATER_SCHEDULE,
-        set_hot_water_schedule,
-    )

homeassistant/components/bsblan/services.yaml

@@ -1,113 +0,0 @@
-set_hot_water_schedule:
-  fields:
-    device_id:
-      required: true
-      example: "abc123device456"
-      selector:
-        device:
-          integration: bsblan
-    monday_slots:
-      selector:
-        object:
-          multiple: true
-          label_field: start_time
-          description_field: end_time
-          fields:
-            start_time:
-              required: true
-              selector:
-                time:
-            end_time:
-              required: true
-              selector:
-                time:
-    tuesday_slots:
-      selector:
-        object:
-          multiple: true
-          label_field: start_time
-          description_field: end_time
-          fields:
-            start_time:
-              required: true
-              selector:
-                time:
-            end_time:
-              required: true
-              selector:
-                time:
-    wednesday_slots:
-      selector:
-        object:
-          multiple: true
-          label_field: start_time
-          description_field: end_time
-          fields:
-            start_time:
-              required: true
-              selector:
-                time:
-            end_time:
-              required: true
-              selector:
-                time:
-    thursday_slots:
-      selector:
-        object:
-          multiple: true
-          label_field: start_time
-          description_field: end_time
-          fields:
-            start_time:
-              required: true
-              selector:
-                time:
-            end_time:
-              required: true
-              selector:
-                time:
-    friday_slots:
-      selector:
-        object:
-          multiple: true
-          label_field: start_time
-          description_field: end_time
-          fields:
-            start_time:
-              required: true
-              selector:
-                time:
-            end_time:
-              required: true
-              selector:
-                time:
-    saturday_slots:
-      selector:
-        object:
-          multiple: true
-          label_field: start_time
-          description_field: end_time
-          fields:
-            start_time:
-              required: true
-              selector:
-                time:
-            end_time:
-              required: true
-              selector:
-                time:
-    sunday_slots:
-      selector:
-        object:
-          multiple: true
-          label_field: start_time
-          description_field: end_time
-          fields:
-            start_time:
-              required: true
-              selector:
-                time:
-            end_time:
-              required: true
-              selector:
-                time:

homeassistant/components/bsblan/strings.json

@@ -70,21 +70,6 @@
     }
   },
   "exceptions": {
-    "config_entry_not_loaded": {
-      "message": "The device `{device_name}` is not currently loaded or available"
-    },
-    "end_time_before_start_time": {
-      "message": "End time ({end_time}) must be after start time ({start_time})"
-    },
-    "invalid_device_id": {
-      "message": "Invalid device ID: {device_id}"
-    },
-    "invalid_time_format": {
-      "message": "Invalid time format provided"
-    },
-    "no_config_entry_for_device": {
-      "message": "No configuration entry found for device: {device_id}"
-    },
     "set_data_error": {
       "message": "An error occurred while sending the data to the BSB-Lan device"
     },
@@ -94,9 +79,6 @@
     "set_preset_mode_error": {
       "message": "Can't set preset mode to {preset_mode} when HVAC mode is not set to auto"
     },
-    "set_schedule_failed": {
-      "message": "Failed to set hot water schedule: {error}"
-    },
     "set_temperature_error": {
       "message": "An error occurred while setting the temperature"
     },
@@ -109,45 +91,5 @@
     "setup_general_error": {
       "message": "An unknown error occurred while retrieving static device data"
     }
-  },
-  "services": {
-    "set_hot_water_schedule": {
-      "description": "Set the hot water heating schedule for a BSB-LAN device.",
-      "fields": {
-        "device_id": {
-          "description": "The BSB-LAN device to configure.",
-          "name": "Device"
-        },
-        "friday_slots": {
-          "description": "Time periods for Friday. Add multiple slots for different heating periods throughout the day.",
-          "name": "Friday time slots"
-        },
-        "monday_slots": {
-          "description": "Time periods for Monday. Add multiple slots for different heating periods throughout the day.",
-          "name": "Monday time slots"
-        },
-        "saturday_slots": {
-          "description": "Time periods for Saturday. Add multiple slots for different heating periods throughout the day.",
-          "name": "Saturday time slots"
-        },
-        "sunday_slots": {
-          "description": "Time periods for Sunday. Add multiple slots for different heating periods throughout the day.",
-          "name": "Sunday time slots"
-        },
-        "thursday_slots": {
-          "description": "Time periods for Thursday. Add multiple slots for different heating periods throughout the day.",
-          "name": "Thursday time slots"
-        },
-        "tuesday_slots": {
-          "description": "Time periods for Tuesday. Add multiple slots for different heating periods throughout the day.",
-          "name": "Tuesday time slots"
-        },
-        "wednesday_slots": {
-          "description": "Time periods for Wednesday. Add multiple slots for different heating periods throughout the day.",
-          "name": "Wednesday time slots"
-        }
-      },
-      "name": "Set hot water schedule"
-    }
   }
 }

homeassistant/components/bthome/manifest.json

@@ -20,5 +20,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bthome",
   "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.17.0"]
+  "requirements": ["bthome-ble==3.15.0"]
 }

homeassistant/components/calendar/icons.json

@@ -15,5 +15,13 @@
     "get_events": {
       "service": "mdi:calendar-month"
     }
+  },
+  "triggers": {
+    "event_ended": {
+      "trigger": "mdi:calendar-end"
+    },
+    "event_started": {
+      "trigger": "mdi:calendar-start"
+    }
   }
 }

homeassistant/components/calendar/strings.json

@@ -1,4 +1,10 @@
 {
+  "common": {
+    "trigger_event_offset_description": "Offset from the event time.",
+    "trigger_event_offset_name": "Offset",
+    "trigger_event_offset_type_description": "Whether to trigger before or after the event time, if an offset is defined.",
+    "trigger_event_offset_type_name": "Offset type"
+  },
   "entity_component": {
     "_": {
       "name": "[%key:component::calendar::title%]",
@@ -45,6 +51,14 @@
       "title": "Detected use of deprecated action calendar.list_events"
     }
   },
+  "selector": {
+    "trigger_offset_type": {
+      "options": {
+        "after": "After",
+        "before": "Before"
+      }
+    }
+  },
   "services": {
     "create_event": {
       "description": "Adds a new calendar event.",
@@ -103,5 +117,35 @@
       "name": "Get events"
     }
   },
-  "title": "Calendar"
+  "title": "Calendar",
+  "triggers": {
+    "event_ended": {
+      "description": "Triggers when a calendar event ends.",
+      "fields": {
+        "offset": {
+          "description": "[%key:component::calendar::common::trigger_event_offset_description%]",
+          "name": "[%key:component::calendar::common::trigger_event_offset_name%]"
+        },
+        "offset_type": {
+          "description": "[%key:component::calendar::common::trigger_event_offset_type_description%]",
+          "name": "[%key:component::calendar::common::trigger_event_offset_type_name%]"
+        }
+      },
+      "name": "Calendar event ended"
+    },
+    "event_started": {
+      "description": "Triggers when a calendar event starts.",
+      "fields": {
+        "offset": {
+          "description": "[%key:component::calendar::common::trigger_event_offset_description%]",
+          "name": "[%key:component::calendar::common::trigger_event_offset_name%]"
+        },
+        "offset_type": {
+          "description": "[%key:component::calendar::common::trigger_event_offset_type_description%]",
+          "name": "[%key:component::calendar::common::trigger_event_offset_type_name%]"
+        }
+      },
+      "name": "Calendar event started"
+    }
+  }
 }

homeassistant/components/calendar/trigger.py

@@ -10,8 +10,14 @@ from typing import TYPE_CHECKING, Any, cast
 
 import voluptuous as vol
 
-from homeassistant.const import CONF_ENTITY_ID, CONF_EVENT, CONF_OFFSET, CONF_OPTIONS
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
+from homeassistant.const import (
+    CONF_ENTITY_ID,
+    CONF_EVENT,
+    CONF_OFFSET,
+    CONF_OPTIONS,
+    CONF_TARGET,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import move_top_level_schema_fields_to_options
@@ -20,12 +26,13 @@ from homeassistant.helpers.event import (
     async_track_point_in_time,
     async_track_time_interval,
 )
+from homeassistant.helpers.target import TargetEntityChangeTracker, TargetSelection
 from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
 
 from . import CalendarEntity, CalendarEvent
-from .const import DATA_COMPONENT
+from .const import DATA_COMPONENT, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -33,19 +40,35 @@ EVENT_START = "start"
 EVENT_END = "end"
 UPDATE_INTERVAL = datetime.timedelta(minutes=15)
 
+CONF_OFFSET_TYPE = "offset_type"
+OFFSET_TYPE_BEFORE = "before"
+OFFSET_TYPE_AFTER = "after"
 
-_OPTIONS_SCHEMA_DICT = {
+
+_SINGLE_ENTITY_OPTIONS_SCHEMA_DICT = {
     vol.Required(CONF_ENTITY_ID): cv.entity_id,
     vol.Optional(CONF_EVENT, default=EVENT_START): vol.In({EVENT_START, EVENT_END}),
     vol.Optional(CONF_OFFSET, default=datetime.timedelta(0)): cv.time_period,
 }
 
-_CONFIG_SCHEMA = vol.Schema(
+_SINGLE_ENTITY_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_OPTIONS): _OPTIONS_SCHEMA_DICT,
+        vol.Required(CONF_OPTIONS): _SINGLE_ENTITY_OPTIONS_SCHEMA_DICT,
     },
 )
 
+_EVENT_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_OPTIONS, default={}): {
+            vol.Optional(CONF_OFFSET, default=datetime.timedelta(0)): cv.time_period,
+            vol.Optional(CONF_OFFSET_TYPE, default=OFFSET_TYPE_BEFORE): vol.In(
+                {OFFSET_TYPE_BEFORE, OFFSET_TYPE_AFTER}
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
 # mypy: disallow-any-generics
 
 
@@ -110,15 +133,19 @@ def get_entity(hass: HomeAssistant, entity_id: str) -> CalendarEntity:
     return entity
 
 
-def event_fetcher(hass: HomeAssistant, entity_id: str) -> EventFetcher:
+def event_fetcher(hass: HomeAssistant, entity_ids: set[str]) -> EventFetcher:
     """Build an async_get_events wrapper to fetch events during a time span."""
 
     async def async_get_events(timespan: Timespan) -> list[CalendarEvent]:
         """Return events active in the specified time span."""
-        entity = get_entity(hass, entity_id)
         # Expand by one second to make the end time exclusive
         end_time = timespan.end + datetime.timedelta(seconds=1)
-        return await entity.async_get_events(hass, timespan.start, end_time)
+
+        events: list[CalendarEvent] = []
+        for entity_id in entity_ids:
+            entity = get_entity(hass, entity_id)
+            events.extend(await entity.async_get_events(hass, timespan.start, end_time))
+        return events
 
     return async_get_events
 
@@ -260,8 +287,68 @@ class CalendarEventListener:
         self._listen_next_calendar_event()
 
 
-class EventTrigger(Trigger):
-    """Calendar event trigger."""
+class TargetCalendarEventListener(TargetEntityChangeTracker):
+    """Helper class to listen to calendar events for target entity changes."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        target_selection: TargetSelection,
+        event_type: str,
+        offset: datetime.timedelta,
+        run_action: TriggerActionRunner,
+    ) -> None:
+        """Initialize the state change tracker."""
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        super().__init__(hass, target_selection, entity_filter)
+        self._event_type = event_type
+        self._offset = offset
+        self._run_action = run_action
+        self._trigger_data = {
+            "event": event_type,
+            "offset": offset,
+        }
+
+        self._calendar_event_listener: CalendarEventListener | None = None
+
+    def _handle_entities(self, tracked_entities: set[str]) -> None:
+        """Handle the tracked entities."""
+        self._hass.async_create_task(self._start_listening(tracked_entities))
+
+    async def _start_listening(self, tracked_entities: set[str]) -> None:
+        """Start listening for calendar events."""
+        _LOGGER.debug("Tracking events for calendars: %s", tracked_entities)
+        if self._calendar_event_listener:
+            self._calendar_event_listener.async_detach()
+        self._calendar_event_listener = CalendarEventListener(
+            self._hass,
+            self._run_action,
+            self._trigger_data,
+            queued_event_fetcher(
+                event_fetcher(self._hass, tracked_entities),
+                self._event_type,
+                self._offset,
+            ),
+        )
+        await self._calendar_event_listener.async_attach()
+
+    def _unsubscribe(self) -> None:
+        """Unsubscribe from all events."""
+        super()._unsubscribe()
+        if self._calendar_event_listener:
+            self._calendar_event_listener.async_detach()
+            self._calendar_event_listener = None
+
+
+class SingleEntityEventTrigger(Trigger):
+    """Legacy single calendar entity event trigger."""
 
     _options: dict[str, Any]
 
@@ -271,7 +358,7 @@ class EventTrigger(Trigger):
     ) -> ConfigType:
         """Validate complete config."""
         complete_config = move_top_level_schema_fields_to_options(
-            complete_config, _OPTIONS_SCHEMA_DICT
+            complete_config, _SINGLE_ENTITY_OPTIONS_SCHEMA_DICT
         )
         return await super().async_validate_complete_config(hass, complete_config)
 
@@ -280,7 +367,7 @@ class EventTrigger(Trigger):
         cls, hass: HomeAssistant, config: ConfigType
     ) -> ConfigType:
         """Validate config."""
-        return cast(ConfigType, _CONFIG_SCHEMA(config))
+        return cast(ConfigType, _SINGLE_ENTITY_SCHEMA(config))
 
     def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
         """Initialize trigger."""
@@ -311,15 +398,72 @@ class EventTrigger(Trigger):
             run_action,
             trigger_data,
             queued_event_fetcher(
-                event_fetcher(self._hass, entity_id), event_type, offset
+                event_fetcher(self._hass, {entity_id}), event_type, offset
             ),
         )
         await listener.async_attach()
         return listener.async_detach
 
 
+class EventTrigger(Trigger):
+    """Calendar event trigger."""
+
+    _options: dict[str, Any]
+    _event_type: str
+
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, _EVENT_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize trigger."""
+        super().__init__(hass, config)
+
+        if TYPE_CHECKING:
+            assert config.target is not None
+            assert config.options is not None
+        self._target = config.target
+        self._options = config.options
+
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach a trigger."""
+
+        offset = self._options[CONF_OFFSET]
+        offset_type = self._options.get(CONF_OFFSET_TYPE, OFFSET_TYPE_BEFORE)
+
+        if offset_type == OFFSET_TYPE_BEFORE:
+            offset = -offset
+
+        target_selection = TargetSelection(self._target)
+        if not target_selection.has_any_target:
+            raise HomeAssistantError(f"No target defined in {self._target}")
+        listener = TargetCalendarEventListener(
+            self._hass, target_selection, self._event_type, offset, run_action
+        )
+        return listener.async_setup()
+
+
+class EventStartedTrigger(EventTrigger):
+    """Calendar event started trigger."""
+
+    _event_type = EVENT_START
+
+
+class EventEndedTrigger(EventTrigger):
+    """Calendar event ended trigger."""
+
+    _event_type = EVENT_END
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
-    "_": EventTrigger,
+    "_": SingleEntityEventTrigger,
+    "event_started": EventStartedTrigger,
+    "event_ended": EventEndedTrigger,
 }
 
 

homeassistant/components/calendar/triggers.yaml

@@ -0,0 +1,27 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: calendar
+  fields:
+    offset:
+      required: true
+      default:
+        days: 0
+        hours: 0
+        minutes: 0
+        seconds: 0
+      selector:
+        duration:
+          enable_day: true
+    offset_type:
+      required: true
+      default: before
+      selector:
+        select:
+          translation_key: trigger_offset_type
+          options:
+            - before
+            - after
+
+event_started: *trigger_common
+event_ended: *trigger_common

homeassistant/components/cast/manifest.json

@@ -12,7 +12,6 @@
   "codeowners": ["@emontnemery"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/cast",
-  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["casttube", "pychromecast"],
   "requirements": ["PyChromecast==14.0.9"],

homeassistant/components/comelit/__init__.py

@@ -5,7 +5,7 @@ from aiocomelit.const import BRIDGE
 from homeassistant.const import CONF_HOST, CONF_PIN, CONF_PORT, CONF_TYPE, Platform
 from homeassistant.core import HomeAssistant
 
-from .const import CONF_VEDO_PIN, DEFAULT_PORT
+from .const import DEFAULT_PORT
 from .coordinator import (
     ComelitBaseCoordinator,
     ComelitConfigEntry,
@@ -22,16 +22,6 @@ BRIDGE_PLATFORMS = [
     Platform.SENSOR,
     Platform.SWITCH,
 ]
-BRIDGE_AND_VEDO_PLATFORMS = [
-    Platform.ALARM_CONTROL_PANEL,
-    Platform.BINARY_SENSOR,
-    Platform.CLIMATE,
-    Platform.COVER,
-    Platform.HUMIDIFIER,
-    Platform.LIGHT,
-    Platform.SENSOR,
-    Platform.SWITCH,
-]
 VEDO_PLATFORMS = [
     Platform.ALARM_CONTROL_PANEL,
     Platform.BINARY_SENSOR,
@@ -47,20 +37,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: ComelitConfigEntry) -> b
     session = await async_client_session(hass)
 
     if entry.data.get(CONF_TYPE, BRIDGE) == BRIDGE:
-        vedo_pin = entry.data.get(CONF_VEDO_PIN)
         coordinator = ComelitSerialBridge(
             hass,
             entry,
             entry.data[CONF_HOST],
             entry.data.get(CONF_PORT, DEFAULT_PORT),
             entry.data[CONF_PIN],
-            vedo_pin,
             session,
         )
         platforms = BRIDGE_PLATFORMS
-        # Add VEDO platforms if vedo_pin is configured
-        if vedo_pin:
-            platforms = BRIDGE_AND_VEDO_PLATFORMS
     else:
         coordinator = ComelitVedoSystem(
             hass,
@@ -86,9 +71,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ComelitConfigEntry) ->
 
     if entry.data.get(CONF_TYPE, BRIDGE) == BRIDGE:
         platforms = BRIDGE_PLATFORMS
-        # Add VEDO platforms if vedo_pin was configured
-        if entry.data.get(CONF_VEDO_PIN):
-            platforms = BRIDGE_AND_VEDO_PLATFORMS
     else:
         platforms = VEDO_PLATFORMS
 

homeassistant/components/comelit/alarm_control_panel.py

@@ -3,10 +3,10 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, cast
+from typing import cast
 
 from aiocomelit.api import ComelitVedoAreaObject
-from aiocomelit.const import ALARM_AREA, AlarmAreaState
+from aiocomelit.const import AlarmAreaState
 
 from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelEntity,
@@ -18,7 +18,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .coordinator import ComelitConfigEntry, ComelitSerialBridge, ComelitVedoSystem
+from .coordinator import ComelitConfigEntry, ComelitVedoSystem
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -56,25 +56,15 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Comelit VEDO system alarm control panel devices."""
 
-    coordinator = config_entry.runtime_data
-    is_bridge = isinstance(coordinator, ComelitSerialBridge)
+    coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    if TYPE_CHECKING:
-        if is_bridge:
-            assert isinstance(coordinator, ComelitSerialBridge)
-        else:
-            assert isinstance(coordinator, ComelitVedoSystem)
-
-    if data := coordinator.data[ALARM_AREA]:
-        async_add_entities(
-            ComelitAlarmEntity(coordinator, device, config_entry.entry_id)
-            for device in data.values()
-        )
+    async_add_entities(
+        ComelitAlarmEntity(coordinator, device, config_entry.entry_id)
+        for device in coordinator.data["alarm_areas"].values()
+    )
 
 
-class ComelitAlarmEntity(
-    CoordinatorEntity[ComelitVedoSystem | ComelitSerialBridge], AlarmControlPanelEntity
-):
+class ComelitAlarmEntity(CoordinatorEntity[ComelitVedoSystem], AlarmControlPanelEntity):
     """Representation of a Ness alarm panel."""
 
     _attr_has_entity_name = True
@@ -88,7 +78,7 @@ class ComelitAlarmEntity(
 
     def __init__(
         self,
-        coordinator: ComelitVedoSystem | ComelitSerialBridge,
+        coordinator: ComelitVedoSystem,
         area: ComelitVedoAreaObject,
         config_entry_entry_id: str,
     ) -> None:
@@ -105,9 +95,7 @@ class ComelitAlarmEntity(
     @property
     def _area(self) -> ComelitVedoAreaObject:
         """Return area object."""
-        return cast(
-            ComelitVedoAreaObject, self.coordinator.data[ALARM_AREA][self._area_index]
-        )
+        return self.coordinator.data["alarm_areas"][self._area_index]
 
     @property
     def available(self) -> bool:

homeassistant/components/comelit/binary_sensor.py

@@ -2,10 +2,9 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+from typing import cast
 
-from aiocomelit.api import ComelitVedoZoneObject
-from aiocomelit.const import ALARM_ZONE, AlarmZoneState
+from aiocomelit import ComelitVedoZoneObject
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
@@ -16,7 +15,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import ObjectClassType
-from .coordinator import ComelitConfigEntry, ComelitSerialBridge, ComelitVedoSystem
+from .coordinator import ComelitConfigEntry, ComelitVedoSystem
 from .utils import new_device_listener
 
 # Coordinator is used to centralize the data updates
@@ -30,32 +29,25 @@ async def async_setup_entry(
 ) -> None:
     """Set up Comelit VEDO presence sensors."""
 
-    coordinator = config_entry.runtime_data
-    is_bridge = isinstance(coordinator, ComelitSerialBridge)
-
-    if TYPE_CHECKING:
-        if is_bridge:
-            assert isinstance(coordinator, ComelitSerialBridge)
-        else:
-            assert isinstance(coordinator, ComelitVedoSystem)
+    coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
     def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
         """Add entities for new monitors."""
         entities = [
             ComelitVedoBinarySensorEntity(coordinator, device, config_entry.entry_id)
-            for device in coordinator.data[dev_type].values()
+            for device in coordinator.data["alarm_zones"].values()
             if device in new_devices
         ]
         if entities:
             async_add_entities(entities)
 
     config_entry.async_on_unload(
-        new_device_listener(coordinator, _add_new_entities, ALARM_ZONE)
+        new_device_listener(coordinator, _add_new_entities, "alarm_zones")
     )
 
 
 class ComelitVedoBinarySensorEntity(
-    CoordinatorEntity[ComelitVedoSystem | ComelitSerialBridge], BinarySensorEntity
+    CoordinatorEntity[ComelitVedoSystem], BinarySensorEntity
 ):
     """Sensor device."""
 
@@ -64,7 +56,7 @@ class ComelitVedoBinarySensorEntity(
 
     def __init__(
         self,
-        coordinator: ComelitVedoSystem | ComelitSerialBridge,
+        coordinator: ComelitVedoSystem,
         zone: ComelitVedoZoneObject,
         config_entry_entry_id: str,
     ) -> None:
@@ -76,25 +68,9 @@ class ComelitVedoBinarySensorEntity(
         self._attr_unique_id = f"{config_entry_entry_id}-presence-{zone.index}"
         self._attr_device_info = coordinator.platform_device_info(zone, "zone")
 
-    @property
-    def _zone(self) -> ComelitVedoZoneObject:
-        """Return zone object."""
-        return cast(
-            ComelitVedoZoneObject, self.coordinator.data[ALARM_ZONE][self._zone_index]
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return True if alarm is available."""
-        if self._zone.human_status in [
-            AlarmZoneState.FAULTY,
-            AlarmZoneState.UNAVAILABLE,
-            AlarmZoneState.UNKNOWN,
-        ]:
-            return False
-        return super().available
-
     @property
     def is_on(self) -> bool:
         """Presence detected."""
-        return self._zone.status_api == "0001"
+        return (
+            self.coordinator.data["alarm_zones"][self._zone_index].status_api == "0001"
+        )

homeassistant/components/comelit/config_flow.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from asyncio.exceptions import TimeoutError
 from collections.abc import Mapping
 import re
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from aiocomelit import (
     ComeliteSerialBridgeApi,
@@ -22,7 +22,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 
-from .const import _LOGGER, CONF_VEDO_PIN, DEFAULT_PORT, DEVICE_TYPE_LIST, DOMAIN
+from .const import _LOGGER, DEFAULT_PORT, DEVICE_TYPE_LIST, DOMAIN
 from .utils import async_client_session
 
 DEFAULT_HOST = "192.168.1.252"
@@ -34,12 +34,9 @@ USER_SCHEMA = vol.Schema(
         vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port,
         vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.string,
         vol.Required(CONF_TYPE, default=BRIDGE): vol.In(DEVICE_TYPE_LIST),
-        vol.Optional(CONF_VEDO_PIN): cv.string,
     }
 )
-STEP_REAUTH_DATA_SCHEMA = vol.Schema(
-    {vol.Required(CONF_PIN): cv.string, vol.Optional(CONF_VEDO_PIN): cv.string}
-)
+STEP_REAUTH_DATA_SCHEMA = vol.Schema({vol.Required(CONF_PIN): cv.string})
 
 
 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, str]:
@@ -75,18 +72,6 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
     finally:
         await api.logout()
 
-    # Validate VEDO PIN if provided and device type is BRIDGE
-    if data.get(CONF_VEDO_PIN) and data.get(CONF_TYPE, BRIDGE) == BRIDGE:
-        if not re.fullmatch(r"[0-9]{4,10}", data[CONF_VEDO_PIN]):
-            raise InvalidVedoPin
-
-        if TYPE_CHECKING:
-            assert isinstance(api, ComeliteSerialBridgeApi)
-
-        # Verify VEDO is enabled with the provided PIN
-        if not await api.vedo_enabled(data[CONF_VEDO_PIN]):
-            raise InvalidVedoAuth
-
     return {"title": data[CONF_HOST]}
 
 
@@ -114,10 +99,6 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
             errors["base"] = "invalid_auth"
         except InvalidPin:
             errors["base"] = "invalid_pin"
-        except InvalidVedoPin:
-            errors["base"] = "invalid_vedo_pin"
-        except InvalidVedoAuth:
-            errors["base"] = "invalid_vedo_auth"
         except Exception:  # noqa: BLE001
             _LOGGER.exception("Unexpected exception")
             errors["base"] = "unknown"
@@ -201,8 +182,6 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
                     CONF_PIN: user_input[CONF_PIN],
                     CONF_TYPE: reconfigure_entry.data.get(CONF_TYPE, BRIDGE),
                 }
-                if CONF_VEDO_PIN in user_input:
-                    data_to_validate[CONF_VEDO_PIN] = user_input[CONF_VEDO_PIN]
                 await validate_input(self.hass, data_to_validate)
             except CannotConnect:
                 errors["base"] = "cannot_connect"
@@ -210,10 +189,6 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
                 errors["base"] = "invalid_auth"
             except InvalidPin:
                 errors["base"] = "invalid_pin"
-            except InvalidVedoPin:
-                errors["base"] = "invalid_vedo_pin"
-            except InvalidVedoAuth:
-                errors["base"] = "invalid_vedo_auth"
             except Exception:  # noqa: BLE001
                 _LOGGER.exception("Unexpected exception")
                 errors["base"] = "unknown"
@@ -223,8 +198,6 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
                     CONF_PORT: user_input[CONF_PORT],
                     CONF_PIN: user_input[CONF_PIN],
                 }
-                if CONF_VEDO_PIN in user_input:
-                    data_updates[CONF_VEDO_PIN] = user_input[CONF_VEDO_PIN]
                 return self.async_update_reload_and_abort(
                     reconfigure_entry, data_updates=data_updates
                 )
@@ -238,7 +211,6 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
                     CONF_PORT, default=reconfigure_entry.data[CONF_PORT]
                 ): cv.port,
                 vol.Optional(CONF_PIN): cv.string,
-                vol.Optional(CONF_VEDO_PIN): cv.string,
             }
         )
 
@@ -259,11 +231,3 @@ class InvalidAuth(HomeAssistantError):
 
 class InvalidPin(HomeAssistantError):
     """Error to indicate an invalid pin."""
-
-
-class InvalidVedoPin(HomeAssistantError):
-    """Error to indicate an invalid VEDO pin."""
-
-
-class InvalidVedoAuth(HomeAssistantError):
-    """Error to indicate VEDO authentication failed."""

homeassistant/components/comelit/const.py

@@ -19,7 +19,6 @@ ObjectClassType = (
 DOMAIN = "comelit"
 DEFAULT_PORT = 80
 DEVICE_TYPE_LIST = [BRIDGE, VEDO]
-CONF_VEDO_PIN = "vedo_pin"
 
 SCAN_INTERVAL = 5
 

homeassistant/components/comelit/coordinator.py

@@ -1,14 +1,17 @@
 """Support for Comelit."""
 
 from abc import abstractmethod
-from collections.abc import Mapping
 from datetime import timedelta
-from typing import TypeVar, cast
+from typing import Any, TypeVar
 
-from aiocomelit.api import ComelitCommonApi, ComeliteSerialBridgeApi, ComelitVedoApi
+from aiocomelit.api import (
+    AlarmDataObject,
+    ComelitCommonApi,
+    ComeliteSerialBridgeApi,
+    ComelitSerialBridgeObject,
+    ComelitVedoApi,
+)
 from aiocomelit.const import (
-    ALARM_AREA,
-    ALARM_ZONE,
     BRIDGE,
     CLIMATE,
     COVER,
@@ -34,10 +37,7 @@ type ComelitConfigEntry = ConfigEntry[ComelitBaseCoordinator]
 
 T = TypeVar(
     "T",
-    bound=dict[
-        str,
-        Mapping[int, ObjectClassType],
-    ],
+    bound=dict[str, dict[int, ComelitSerialBridgeObject]] | AlarmDataObject,
 )
 
 
@@ -118,8 +118,8 @@ class ComelitBaseCoordinator(DataUpdateCoordinator[T]):
 
     async def _async_remove_stale_devices(
         self,
-        previous_list: Mapping[int, ObjectClassType],
-        current_list: Mapping[int, ObjectClassType],
+        previous_list: dict[int, Any],
+        current_list: dict[int, Any],
         dev_type: str,
     ) -> None:
         """Remove stale devices."""
@@ -143,7 +143,9 @@ class ComelitBaseCoordinator(DataUpdateCoordinator[T]):
                     )
 
 
-class ComelitSerialBridge(ComelitBaseCoordinator[T]):
+class ComelitSerialBridge(
+    ComelitBaseCoordinator[dict[str, dict[int, ComelitSerialBridgeObject]]]
+):
     """Queries Comelit Serial Bridge."""
 
     _hw_version = "20003101"
@@ -156,23 +158,17 @@ class ComelitSerialBridge(ComelitBaseCoordinator[T]):
         host: str,
         port: int,
         pin: str,
-        vedo_pin: str | None,
         session: ClientSession,
     ) -> None:
         """Initialize the scanner."""
         self.api = ComeliteSerialBridgeApi(host, port, pin, session)
-        self.vedo_pin = vedo_pin
         super().__init__(hass, entry, BRIDGE, host)
 
     async def _async_update_system_data(
         self,
-    ) -> T:
+    ) -> dict[str, dict[int, ComelitSerialBridgeObject]]:
         """Specific method for updating data."""
-        data: dict[
-            str,
-            Mapping[int, ObjectClassType],
-        ] = {}
-        data.update(await self.api.get_all_devices())
+        data = await self.api.get_all_devices()
 
         if self.data:
             for dev_type in (CLIMATE, COVER, LIGHT, IRRIGATION, OTHER, SCENARIO):
@@ -180,14 +176,10 @@ class ComelitSerialBridge(ComelitBaseCoordinator[T]):
                     self.data[dev_type], data[dev_type], dev_type
                 )
 
-        # Get VEDO alarm data if vedo_pin is configured
-        if self.vedo_pin:
-            data.update(await self.api.get_all_areas_and_zones())
-
-        return cast(T, data)
+        return data
 
 
-class ComelitVedoSystem(ComelitBaseCoordinator[T]):
+class ComelitVedoSystem(ComelitBaseCoordinator[AlarmDataObject]):
     """Queries Comelit VEDO system."""
 
     _hw_version = "VEDO IP"
@@ -204,21 +196,20 @@ class ComelitVedoSystem(ComelitBaseCoordinator[T]):
     ) -> None:
         """Initialize the scanner."""
         self.api = ComelitVedoApi(host, port, pin, session)
-        self.vedo_pin = pin
         super().__init__(hass, entry, VEDO, host)
 
     async def _async_update_system_data(
         self,
-    ) -> T:
+    ) -> AlarmDataObject:
         """Specific method for updating data."""
         data = await self.api.get_all_areas_and_zones()
 
         if self.data:
-            for obj_type in (ALARM_AREA, ALARM_ZONE):
+            for obj_type in ("alarm_areas", "alarm_zones"):
                 await self._async_remove_stale_devices(
                     self.data[obj_type],
                     data[obj_type],
-                    "area" if obj_type == ALARM_AREA else "zone",
+                    "area" if obj_type == "alarm_areas" else "zone",
                 )
 
-        return cast(T, data)
+        return data

homeassistant/components/comelit/cover.py

@@ -72,7 +72,7 @@ class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
     @property
     def device_status(self) -> int:
         """Return current device status."""
-        return cast("int", self.coordinator.data[COVER][self._device.index].status)
+        return self.coordinator.data[COVER][self._device.index].status
 
     @property
     def is_closed(self) -> bool | None:
@@ -86,7 +86,7 @@ class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
     @property
     def is_closing(self) -> bool:
         """Return if the cover is closing."""
-        return bool(self._current_action("closing"))
+        return self._current_action("closing")
 
     @property
     def is_opening(self) -> bool:

homeassistant/components/comelit/light.py

@@ -68,4 +68,4 @@ class ComelitLightEntity(ComelitBridgeBaseEntity, LightEntity):
     @property
     def is_on(self) -> bool:
         """Return True if light is on."""
-        return bool(self.coordinator.data[LIGHT][self._device.index].status == STATE_ON)
+        return self.coordinator.data[LIGHT][self._device.index].status == STATE_ON

homeassistant/components/comelit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["aiocomelit"],
   "quality_scale": "platinum",
-  "requirements": ["aiocomelit==2.0.0"]
+  "requirements": ["aiocomelit==1.1.2"]
 }

homeassistant/components/comelit/sensor.py

@@ -2,17 +2,17 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Final, cast
+from typing import Final, cast
 
 from aiocomelit.api import ComelitSerialBridgeObject, ComelitVedoZoneObject
-from aiocomelit.const import ALARM_ZONE, OTHER, AlarmZoneState
+from aiocomelit.const import BRIDGE, OTHER, AlarmZoneState
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
 )
-from homeassistant.const import UnitOfPower
+from homeassistant.const import CONF_TYPE, UnitOfPower
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -52,20 +52,23 @@ async def async_setup_entry(
 ) -> None:
     """Set up Comelit sensors."""
 
-    coordinator = config_entry.runtime_data
-    is_bridge = isinstance(coordinator, ComelitSerialBridge)
+    if config_entry.data.get(CONF_TYPE, BRIDGE) == BRIDGE:
+        await async_setup_bridge_entry(hass, config_entry, async_add_entities)
+    else:
+        await async_setup_vedo_entry(hass, config_entry, async_add_entities)
 
-    if TYPE_CHECKING:
-        if is_bridge:
-            assert isinstance(coordinator, ComelitSerialBridge)
-        else:
-            assert isinstance(coordinator, ComelitVedoSystem)
 
-    def _add_new_bridge_entities(
-        new_devices: list[ObjectClassType], dev_type: str
-    ) -> None:
+async def async_setup_bridge_entry(
+    hass: HomeAssistant,
+    config_entry: ComelitConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Comelit Bridge sensors."""
+
+    coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
+
+    def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
         """Add entities for new monitors."""
-        assert isinstance(coordinator, ComelitSerialBridge)
         entities = [
             ComelitBridgeSensorEntity(
                 coordinator, device, config_entry.entry_id, sensor_desc
@@ -77,32 +80,36 @@ async def async_setup_entry(
         if entities:
             async_add_entities(entities)
 
-    def _add_new_vedo_entities(
-        new_devices: list[ObjectClassType], dev_type: str
-    ) -> None:
+    config_entry.async_on_unload(
+        new_device_listener(coordinator, _add_new_entities, OTHER)
+    )
+
+
+async def async_setup_vedo_entry(
+    hass: HomeAssistant,
+    config_entry: ComelitConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Comelit VEDO sensors."""
+
+    coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
+
+    def _add_new_entities(new_devices: list[ObjectClassType], dev_type: str) -> None:
         """Add entities for new monitors."""
         entities = [
             ComelitVedoSensorEntity(
                 coordinator, device, config_entry.entry_id, sensor_desc
             )
             for sensor_desc in SENSOR_VEDO_TYPES
-            for device in coordinator.data[dev_type].values()
+            for device in coordinator.data["alarm_zones"].values()
             if device in new_devices
         ]
         if entities:
             async_add_entities(entities)
 
-    # Bridge native sensors
-    if is_bridge:
-        config_entry.async_on_unload(
-            new_device_listener(coordinator, _add_new_bridge_entities, OTHER)
-        )
-
-    # Alarm sensors (both via Bridge or VedoSystem)
-    if coordinator.vedo_pin:
-        config_entry.async_on_unload(
-            new_device_listener(coordinator, _add_new_vedo_entities, ALARM_ZONE)
-        )
+    config_entry.async_on_unload(
+        new_device_listener(coordinator, _add_new_entities, "alarm_zones")
+    )
 
 
 class ComelitBridgeSensorEntity(ComelitBridgeBaseEntity, SensorEntity):
@@ -134,16 +141,14 @@ class ComelitBridgeSensorEntity(ComelitBridgeBaseEntity, SensorEntity):
         )
 
 
-class ComelitVedoSensorEntity(
-    CoordinatorEntity[ComelitVedoSystem | ComelitSerialBridge], SensorEntity
-):
+class ComelitVedoSensorEntity(CoordinatorEntity[ComelitVedoSystem], SensorEntity):
     """Sensor device."""
 
     _attr_has_entity_name = True
 
     def __init__(
         self,
-        coordinator: ComelitVedoSystem | ComelitSerialBridge,
+        coordinator: ComelitVedoSystem,
         zone: ComelitVedoZoneObject,
         config_entry_entry_id: str,
         description: SensorEntityDescription,
@@ -161,9 +166,7 @@ class ComelitVedoSensorEntity(
     @property
     def _zone_object(self) -> ComelitVedoZoneObject:
         """Zone object."""
-        return cast(
-            ComelitVedoZoneObject, self.coordinator.data[ALARM_ZONE][self._zone_index]
-        )
+        return self.coordinator.data["alarm_zones"][self._zone_index]
 
     @property
     def available(self) -> bool:

homeassistant/components/comelit/strings.json

@@ -5,8 +5,6 @@
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
       "invalid_pin": "The provided PIN is invalid. It must be a 4-10 digit number.",
-      "invalid_vedo_auth": "The provided VEDO PIN is incorrect or VEDO alarm is not enabled on this device.",
-      "invalid_vedo_pin": "The provided VEDO PIN is invalid. It must be a 4-10 digit number.",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
@@ -15,34 +13,28 @@
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
       "invalid_pin": "[%key:component::comelit::config::abort::invalid_pin%]",
-      "invalid_vedo_auth": "[%key:component::comelit::config::abort::invalid_vedo_auth%]",
-      "invalid_vedo_pin": "[%key:component::comelit::config::abort::invalid_vedo_pin%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "flow_title": "{host}",
     "step": {
       "reauth_confirm": {
         "data": {
-          "pin": "[%key:common::config_flow::data::pin%]",
-          "vedo_pin": "[%key:component::comelit::config::step::user::data::vedo_pin%]"
+          "pin": "[%key:common::config_flow::data::pin%]"
         },
         "data_description": {
-          "pin": "The PIN of your Comelit device.",
-          "vedo_pin": "[%key:component::comelit::config::step::user::data_description::vedo_pin%]"
+          "pin": "The PIN of your Comelit device."
         }
       },
       "reconfigure": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
           "pin": "[%key:common::config_flow::data::pin%]",
-          "port": "[%key:common::config_flow::data::port%]",
-          "vedo_pin": "[%key:component::comelit::config::step::user::data::vedo_pin%]"
+          "port": "[%key:common::config_flow::data::port%]"
         },
         "data_description": {
           "host": "[%key:component::comelit::config::step::user::data_description::host%]",
           "pin": "[%key:component::comelit::config::step::reauth_confirm::data_description::pin%]",
-          "port": "[%key:component::comelit::config::step::user::data_description::port%]",
-          "vedo_pin": "[%key:component::comelit::config::step::user::data_description::vedo_pin%]"
+          "port": "[%key:component::comelit::config::step::user::data_description::port%]"
         }
       },
       "user": {
@@ -50,15 +42,13 @@
           "host": "[%key:common::config_flow::data::host%]",
           "pin": "[%key:common::config_flow::data::pin%]",
           "port": "[%key:common::config_flow::data::port%]",
-          "type": "Device type",
-          "vedo_pin": "VEDO alarm PIN (optional)"
+          "type": "Device type"
         },
         "data_description": {
           "host": "The hostname or IP address of your Comelit device.",
           "pin": "[%key:component::comelit::config::step::reauth_confirm::data_description::pin%]",
           "port": "The port of your Comelit device.",
-          "type": "The type of your Comelit device.",
-          "vedo_pin": "Optional PIN for VEDO alarm system on Serial Bridge devices. Leave empty if you don't have VEDO alarm enabled."
+          "type": "The type of your Comelit device."
         }
       }
     }

homeassistant/components/comelit/switch.py

@@ -82,7 +82,7 @@ class ComelitSwitchEntity(ComelitBridgeBaseEntity, SwitchEntity):
     @property
     def is_on(self) -> bool:
         """Return True if switch is on."""
-        return bool(
+        return (
             self.coordinator.data[self._device.type][self._device.index].status
             == STATE_ON
         )

homeassistant/components/control4/light.py

@@ -66,7 +66,6 @@ async def async_setup_entry(
         name="light",
         update_method=async_update_data_non_dimmer,
         update_interval=timedelta(seconds=runtime_data.scan_interval),
-        config_entry=entry,
     )
     dimmer_coordinator = DataUpdateCoordinator[dict[int, dict[str, Any]]](
         hass,
@@ -74,7 +73,6 @@ async def async_setup_entry(
         name="light",
         update_method=async_update_data_dimmer,
         update_interval=timedelta(seconds=runtime_data.scan_interval),
-        config_entry=entry,
     )
 
     # Fetch initial data so we have data when entities subscribe

homeassistant/components/control4/media_player.py

@@ -110,7 +110,6 @@ async def async_setup_entry(
         name="room",
         update_method=async_update_data,
         update_interval=timedelta(seconds=scan_interval),
-        config_entry=entry,
     )
 
     # Fetch initial data so we have data when entities subscribe

homeassistant/components/cookidoo/__init__.py

@@ -14,12 +14,7 @@ from .const import DOMAIN
 from .coordinator import CookidooConfigEntry, CookidooDataUpdateCoordinator
 from .helpers import cookidoo_from_config_entry
 
-PLATFORMS: list[Platform] = [
-    Platform.BUTTON,
-    Platform.CALENDAR,
-    Platform.SENSOR,
-    Platform.TODO,
-]
+PLATFORMS: list[Platform] = [Platform.BUTTON, Platform.SENSOR, Platform.TODO]
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/cookidoo/calendar.py

@@ -1,103 +0,0 @@
-"""Calendar platform for the Cookidoo integration."""
-
-from __future__ import annotations
-
-from datetime import date, datetime, timedelta
-import logging
-
-from cookidoo_api import CookidooAuthException, CookidooException
-from cookidoo_api.types import CookidooCalendarDayRecipe
-
-from homeassistant.components.calendar import CalendarEntity, CalendarEvent
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import DOMAIN
-from .coordinator import CookidooConfigEntry, CookidooDataUpdateCoordinator
-from .entity import CookidooBaseEntity
-
-_LOGGER = logging.getLogger(__name__)
-
-PARALLEL_UPDATES = 0
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: CookidooConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the calendar platform for entity."""
-    coordinator = config_entry.runtime_data
-
-    async_add_entities([CookidooCalendarEntity(coordinator)])
-
-
-def recipe_to_event(day_date: date, recipe: CookidooCalendarDayRecipe) -> CalendarEvent:
-    """Convert a Cookidoo recipe to a CalendarEvent."""
-    return CalendarEvent(
-        start=day_date,
-        end=day_date + timedelta(days=1),  # All-day event
-        summary=recipe.name,
-        description=f"Total Time: {recipe.total_time}",
-    )
-
-
-class CookidooCalendarEntity(CookidooBaseEntity, CalendarEntity):
-    """A calendar entity."""
-
-    _attr_translation_key = "meal_plan"
-
-    def __init__(self, coordinator: CookidooDataUpdateCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        assert coordinator.config_entry.unique_id
-        self._attr_unique_id = coordinator.config_entry.unique_id
-
-    @property
-    def event(self) -> CalendarEvent | None:
-        """Return the next upcoming event."""
-        if not self.coordinator.data.week_plan:
-            return None
-
-        today = date.today()
-        for day_data in self.coordinator.data.week_plan:
-            day_date = date.fromisoformat(day_data.id)
-            if day_date >= today and day_data.recipes:
-                recipe = day_data.recipes[0]
-                return recipe_to_event(day_date, recipe)
-        return None
-
-    async def _fetch_week_plan(self, week_day: date) -> list:
-        """Fetch a single Cookidoo week plan, retrying once on auth failure."""
-        try:
-            return await self.coordinator.cookidoo.get_recipes_in_calendar_week(
-                week_day
-            )
-        except CookidooAuthException:
-            await self.coordinator.cookidoo.refresh_token()
-            return await self.coordinator.cookidoo.get_recipes_in_calendar_week(
-                week_day
-            )
-        except CookidooException as e:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="calendar_fetch_failed",
-            ) from e
-
-    async def async_get_events(
-        self, hass: HomeAssistant, start_date: datetime, end_date: datetime
-    ) -> list[CalendarEvent]:
-        """Get all events in a specific time frame."""
-        events: list[CalendarEvent] = []
-        current_day = start_date.date()
-        while current_day <= end_date.date():
-            week_plan = await self._fetch_week_plan(current_day)
-            for day_data in week_plan:
-                day_date = date.fromisoformat(day_data.id)
-                if start_date.date() <= day_date <= end_date.date():
-                    events.extend(
-                        recipe_to_event(day_date, recipe) for recipe in day_data.recipes
-                    )
-            current_day += timedelta(days=7)  # Move to the next week
-        return events

homeassistant/components/cookidoo/coordinator.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import date, timedelta
+from datetime import timedelta
 import logging
 
 from cookidoo_api import (
@@ -16,7 +16,6 @@ from cookidoo_api import (
     CookidooSubscription,
     CookidooUserInfo,
 )
-from cookidoo_api.types import CookidooCalendarDay
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_EMAIL
@@ -38,7 +37,6 @@ class CookidooData:
     ingredient_items: list[CookidooIngredientItem]
     additional_items: list[CookidooAdditionalItem]
     subscription: CookidooSubscription | None
-    week_plan: list[CookidooCalendarDay]
 
 
 class CookidooDataUpdateCoordinator(DataUpdateCoordinator[CookidooData]):
@@ -83,7 +81,6 @@ class CookidooDataUpdateCoordinator(DataUpdateCoordinator[CookidooData]):
             ingredient_items = await self.cookidoo.get_ingredient_items()
             additional_items = await self.cookidoo.get_additional_items()
             subscription = await self.cookidoo.get_active_subscription()
-            week_plan = await self.cookidoo.get_recipes_in_calendar_week(date.today())
         except CookidooAuthException:
             try:
                 await self.cookidoo.refresh_token()
@@ -109,5 +106,4 @@ class CookidooDataUpdateCoordinator(DataUpdateCoordinator[CookidooData]):
             ingredient_items=ingredient_items,
             additional_items=additional_items,
             subscription=subscription,
-            week_plan=week_plan,
         )

homeassistant/components/cookidoo/strings.json

@@ -54,11 +54,6 @@
         "name": "Clear shopping list and additional purchases"
       }
     },
-    "calendar": {
-      "meal_plan": {
-        "name": "Meal plan"
-      }
-    },
     "sensor": {
       "expires": {
         "name": "Subscription expiration date"
@@ -85,9 +80,6 @@
     "button_clear_todo_failed": {
       "message": "Failed to clear all items from the Cookidoo shopping list"
     },
-    "calendar_fetch_failed": {
-      "message": "Failed to fetch Cookidoo meal plan"
-    },
     "setup_authentication_exception": {
       "message": "Authentication failed for {email}, check your email and password"
     },

homeassistant/components/duckdns/__init__.py

@@ -8,16 +8,25 @@ import voluptuous as vol
 
 from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import ConfigEntrySelector
 from homeassistant.helpers.typing import ConfigType
 
-from .const import DOMAIN
+from .const import ATTR_CONFIG_ENTRY
 from .coordinator import DuckDnsConfigEntry, DuckDnsUpdateCoordinator
-from .services import async_setup_services
+from .helpers import update_duckdns
 
 _LOGGER = logging.getLogger(__name__)
 
+ATTR_TXT = "txt"
+
+DOMAIN = "duckdns"
+
+SERVICE_SET_TXT = "set_txt"
+
 
 CONFIG_SCHEMA = vol.Schema(
     {
@@ -31,11 +40,27 @@ CONFIG_SCHEMA = vol.Schema(
     extra=vol.ALLOW_EXTRA,
 )
 
+SERVICE_TXT_SCHEMA = vol.Schema(
+    {
+        vol.Optional(ATTR_CONFIG_ENTRY): ConfigEntrySelector(
+            {
+                "integration": DOMAIN,
+            }
+        ),
+        vol.Optional(ATTR_TXT): vol.Any(None, cv.string),
+    }
+)
+
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Initialize the DuckDNS component."""
 
-    async_setup_services(hass)
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_SET_TXT,
+        update_domain_service,
+        schema=SERVICE_TXT_SCHEMA,
+    )
 
     if DOMAIN not in config:
         return True
@@ -62,6 +87,49 @@ async def async_setup_entry(hass: HomeAssistant, entry: DuckDnsConfigEntry) -> b
     return True
 
 
+def get_config_entry(
+    hass: HomeAssistant, entry_id: str | None = None
+) -> DuckDnsConfigEntry:
+    """Return config entry or raise if not found or not loaded."""
+
+    if entry_id is None:
+        if not (config_entries := hass.config_entries.async_entries(DOMAIN)):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="entry_not_found",
+            )
+
+        if len(config_entries) != 1:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="entry_not_selected",
+            )
+        return config_entries[0]
+
+    if not (entry := hass.config_entries.async_get_entry(entry_id)):
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="entry_not_found",
+        )
+
+    return entry
+
+
+async def update_domain_service(call: ServiceCall) -> None:
+    """Update the DuckDNS entry."""
+
+    entry = get_config_entry(call.hass, call.data.get(ATTR_CONFIG_ENTRY))
+
+    session = async_get_clientsession(call.hass)
+
+    await update_duckdns(
+        session,
+        entry.data[CONF_DOMAIN],
+        entry.data[CONF_ACCESS_TOKEN],
+        txt=call.data.get(ATTR_TXT),
+    )
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: DuckDnsConfigEntry) -> bool:
     """Unload a config entry."""
     return True

homeassistant/components/duckdns/const.py

@@ -5,5 +5,3 @@ from typing import Final
 DOMAIN = "duckdns"
 
 ATTR_CONFIG_ENTRY: Final = "config_entry_id"
-ATTR_TXT: Final = "txt"
-SERVICE_SET_TXT = "set_txt"

homeassistant/components/duckdns/services.py

@@ -1,70 +0,0 @@
-"""Actions for Duck DNS."""
-
-from __future__ import annotations
-
-import voluptuous as vol
-
-from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
-from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.selector import ConfigEntrySelector
-
-from .const import ATTR_CONFIG_ENTRY, ATTR_TXT, DOMAIN, SERVICE_SET_TXT
-from .coordinator import DuckDnsConfigEntry
-from .helpers import update_duckdns
-
-SERVICE_TXT_SCHEMA = vol.Schema(
-    {
-        vol.Optional(ATTR_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
-        vol.Optional(ATTR_TXT): vol.Any(None, cv.string),
-    }
-)
-
-
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
-    """Set up services for Habitica integration."""
-
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_SET_TXT,
-        update_domain_service,
-        schema=SERVICE_TXT_SCHEMA,
-    )
-
-
-def get_config_entry(
-    hass: HomeAssistant, entry_id: str | None = None
-) -> DuckDnsConfigEntry:
-    """Return config entry or raise if not found or not loaded."""
-
-    if entry_id is None:
-        if len(entries := hass.config_entries.async_entries(DOMAIN)) != 1:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_selected",
-            )
-        return entries[0]
-    if not (entry := hass.config_entries.async_get_entry(entry_id)):
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="entry_not_found",
-        )
-    return entry
-
-
-async def update_domain_service(call: ServiceCall) -> None:
-    """Update the DuckDNS entry."""
-
-    entry = get_config_entry(call.hass, call.data.get(ATTR_CONFIG_ENTRY))
-
-    session = async_get_clientsession(call.hass)
-
-    await update_duckdns(
-        session,
-        entry.data[CONF_DOMAIN],
-        entry.data[CONF_ACCESS_TOKEN],
-        txt=call.data.get(ATTR_TXT),
-    )

homeassistant/components/ecoforest/strings.json

@@ -35,7 +35,7 @@
           "cpu_overheating": "CPU overheating",
           "none": "None",
           "pellets": "Pellets",
-          "unknown": "Unknown alarm"
+          "unkownn": "Unknown alarm"
         }
       },
       "convector_air_flow": {

homeassistant/components/elevenlabs/stt.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from collections.abc import AsyncIterable
 from io import BytesIO
 import logging
-from typing import Any
 
 from elevenlabs import AsyncElevenLabs
 from elevenlabs.core import ApiError
@@ -181,17 +180,15 @@ class ElevenLabsSTTEntity(SpeechToTextEntity):
         )
 
         try:
-            kwargs: dict[str, Any] = {
-                "file": BytesIO(audio),
-                "file_format": file_format,
-                "model_id": self._stt_model,
-                "tag_audio_events": False,
-                "num_speakers": 1,
-                "diarize": False,
-            }
-            if lang_code is not None:
-                kwargs["language_code"] = lang_code
-            response = await self._client.speech_to_text.convert(**kwargs)
+            response = await self._client.speech_to_text.convert(
+                file=BytesIO(audio),
+                file_format=file_format,
+                model_id=self._stt_model,
+                language_code=lang_code,
+                tag_audio_events=False,
+                num_speakers=1,
+                diarize=False,
+            )
         except ApiError as exc:
             _LOGGER.error("Error during processing of STT request: %s", exc)
             return stt.SpeechResult(None, SpeechResultState.ERROR)

homeassistant/components/enphase_envoy/sensor.py

@@ -620,7 +620,6 @@ ENCHARGE_INVENTORY_SENSORS = (
     EnvoyEnchargeSensorEntityDescription(
         key="temperature",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.TEMPERATURE,
         value_fn=attrgetter("temperature"),
     ),
@@ -635,7 +634,6 @@ ENCHARGE_INVENTORY_SENSORS = (
 ENCHARGE_POWER_SENSORS = (
     EnvoyEnchargePowerSensorEntityDescription(
         key="soc",
-        state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement=PERCENTAGE,
         device_class=SensorDeviceClass.BATTERY,
         value_fn=attrgetter("soc"),
@@ -643,14 +641,12 @@ ENCHARGE_POWER_SENSORS = (
     EnvoyEnchargePowerSensorEntityDescription(
         key="apparent_power_mva",
         native_unit_of_measurement=UnitOfApparentPower.VOLT_AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.APPARENT_POWER,
         value_fn=lambda encharge: encharge.apparent_power_mva * 0.001,
     ),
     EnvoyEnchargePowerSensorEntityDescription(
         key="real_power_mw",
         native_unit_of_measurement=UnitOfPower.WATT,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.POWER,
         value_fn=lambda encharge: encharge.real_power_mw * 0.001,
     ),
@@ -668,7 +664,6 @@ ENPOWER_SENSORS = (
     EnvoyEnpowerSensorEntityDescription(
         key="temperature",
         native_unit_of_measurement=UnitOfTemperature.FAHRENHEIT,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.TEMPERATURE,
         value_fn=attrgetter("temperature"),
     ),
@@ -698,7 +693,6 @@ COLLAR_SENSORS = (
     EnvoyCollarSensorEntityDescription(
         key="temperature",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.TEMPERATURE,
         value_fn=attrgetter("temperature"),
     ),
@@ -766,7 +760,6 @@ ENCHARGE_AGGREGATE_SENSORS = (
     EnvoyEnchargeAggregateSensorEntityDescription(
         key="battery_level",
         native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.BATTERY,
         value_fn=attrgetter("state_of_charge"),
     ),
@@ -774,7 +767,6 @@ ENCHARGE_AGGREGATE_SENSORS = (
         key="reserve_soc",
         translation_key="reserve_soc",
         native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.BATTERY,
         value_fn=attrgetter("reserve_state_of_charge"),
     ),
@@ -782,7 +774,6 @@ ENCHARGE_AGGREGATE_SENSORS = (
         key="available_energy",
         translation_key="available_energy",
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.ENERGY,
         value_fn=attrgetter("available_energy"),
     ),
@@ -790,7 +781,6 @@ ENCHARGE_AGGREGATE_SENSORS = (
         key="reserve_energy",
         translation_key="reserve_energy",
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.ENERGY,
         value_fn=attrgetter("backup_reserve"),
     ),
@@ -815,14 +805,12 @@ ACB_BATTERY_POWER_SENSORS = (
     EnvoyAcbBatterySensorEntityDescription(
         key="acb_power",
         native_unit_of_measurement=UnitOfPower.WATT,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.POWER,
         value_fn=attrgetter("power"),
     ),
     EnvoyAcbBatterySensorEntityDescription(
         key="acb_soc",
         native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.BATTERY,
         value_fn=attrgetter("state_of_charge"),
     ),
@@ -840,7 +828,6 @@ ACB_BATTERY_ENERGY_SENSORS = (
         key="acb_available_energy",
         translation_key="acb_available_energy",
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.ENERGY_STORAGE,
         value_fn=attrgetter("charge_wh"),
     ),
@@ -858,7 +845,6 @@ AGGREGATE_BATTERY_SENSORS = (
     EnvoyAggregateBatterySensorEntityDescription(
         key="aggregated_soc",
         translation_key="aggregated_soc",
-        state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement=PERCENTAGE,
         device_class=SensorDeviceClass.BATTERY,
         value_fn=attrgetter("state_of_charge"),
@@ -867,7 +853,6 @@ AGGREGATE_BATTERY_SENSORS = (
         key="aggregated_available_energy",
         translation_key="aggregated_available_energy",
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.ENERGY_STORAGE,
         value_fn=attrgetter("available_energy"),
     ),

homeassistant/components/esphome/manifest.json

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

homeassistant/components/esphome/repairs.py

@@ -8,7 +8,8 @@ import voluptuous as vol
 
 from homeassistant import data_entry_flow
 from homeassistant.components.repairs import RepairsFlow
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import issue_registry as ir
 
 from .manager import async_replace_device
 
@@ -21,6 +22,13 @@ class ESPHomeRepair(RepairsFlow):
         self._data = data
         super().__init__()
 
+    @callback
+    def _async_get_placeholders(self) -> dict[str, str]:
+        issue_registry = ir.async_get(self.hass)
+        issue = issue_registry.async_get_issue(self.handler, self.issue_id)
+        assert issue is not None
+        return issue.translation_placeholders or {}
+
 
 class DeviceConflictRepair(ESPHomeRepair):
     """Handler for an issue fixing device conflict."""
@@ -50,6 +58,7 @@ class DeviceConflictRepair(ESPHomeRepair):
         return self.async_show_menu(
             step_id="init",
             menu_options=["migrate", "manual"],
+            description_placeholders=self._async_get_placeholders(),
         )
 
     async def async_step_migrate(
@@ -60,6 +69,7 @@ class DeviceConflictRepair(ESPHomeRepair):
             return self.async_show_form(
                 step_id="migrate",
                 data_schema=vol.Schema({}),
+                description_placeholders=self._async_get_placeholders(),
             )
         entry_id = self.entry_id
         await async_replace_device(self.hass, entry_id, self.stored_mac, self.mac)
@@ -74,6 +84,7 @@ class DeviceConflictRepair(ESPHomeRepair):
             return self.async_show_form(
                 step_id="manual",
                 data_schema=vol.Schema({}),
+                description_placeholders=self._async_get_placeholders(),
             )
         self.hass.config_entries.async_schedule_reload(self.entry_id)
         return self.async_create_entry(data={})

homeassistant/components/feedreader/__init__.py

@@ -9,12 +9,14 @@ from homeassistant.util.hass_dict import HassKey
 from .const import DOMAIN
 from .coordinator import FeedReaderConfigEntry, FeedReaderCoordinator, StoredData
 
-FEEDREADER_KEY: HassKey[StoredData] = HassKey(DOMAIN)
+CONF_URLS = "urls"
+
+MY_KEY: HassKey[StoredData] = HassKey(DOMAIN)
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: FeedReaderConfigEntry) -> bool:
     """Set up Feedreader from a config entry."""
-    storage = hass.data.setdefault(FEEDREADER_KEY, StoredData(hass))
+    storage = hass.data.setdefault(MY_KEY, StoredData(hass))
     if not storage.is_initialized:
         await storage.async_setup()
 
@@ -40,5 +42,5 @@ async def async_unload_entry(hass: HomeAssistant, entry: FeedReaderConfigEntry)
     )
     # if this is the last entry, remove the storage
     if len(entries) == 1:
-        hass.data.pop(FEEDREADER_KEY)
+        hass.data.pop(MY_KEY)
     return await hass.config_entries.async_unload_platforms(entry, [Platform.EVENT])

homeassistant/components/feedreader/event.py

@@ -19,9 +19,6 @@ from .coordinator import FeedReaderCoordinator
 
 LOGGER = logging.getLogger(__name__)
 
-# Coordinator is used to centralize the data updates
-PARALLEL_UPDATES = 0
-
 ATTR_CONTENT = "content"
 ATTR_DESCRIPTION = "description"
 ATTR_LINK = "link"
@@ -45,15 +42,16 @@ class FeedReaderEvent(CoordinatorEntity[FeedReaderCoordinator], EventEntity):
     _attr_event_types = [EVENT_FEEDREADER]
     _attr_name = None
     _attr_has_entity_name = True
-    _attr_translation_key = "latest_feed"
     _unrecorded_attributes = frozenset(
         {ATTR_CONTENT, ATTR_DESCRIPTION, ATTR_TITLE, ATTR_LINK}
     )
+    coordinator: FeedReaderCoordinator
 
     def __init__(self, coordinator: FeedReaderCoordinator) -> None:
         """Initialize the feedreader event."""
         super().__init__(coordinator)
         self._attr_unique_id = f"{coordinator.config_entry.entry_id}_latest_feed"
+        self._attr_translation_key = "latest_feed"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, coordinator.config_entry.entry_id)},
             name=coordinator.config_entry.title,

homeassistant/components/feedreader/quality_scale.yaml

@@ -1,94 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: No custom actions are defined.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage:
-    status: todo
-    comment: missing test for uniqueness of feed URL.
-  config-flow:
-    status: todo
-    comment: missing data descriptions
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: No custom actions are defined.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: No custom actions are defined.
-  config-entry-unloading: done
-  docs-configuration-parameters: done
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: done
-  reauthentication-flow:
-    status: exempt
-    comment: No authentication support.
-  test-coverage:
-    status: done
-    comment: Can use freezer for skipping time instead
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: No discovery support.
-  discovery:
-    status: exempt
-    comment: No discovery support.
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: done
-  dynamic-devices:
-    status: exempt
-    comment: Each config entry, represents one service.
-  entity-category: done
-  entity-device-class:
-    status: exempt
-    comment: Matches no available event entity class.
-  entity-disabled-by-default:
-    status: exempt
-    comment: Only one entity per config entry.
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: done
-  reconfiguration-flow: done
-  repair-issues:
-    status: done
-    comment: Only one repair-issue for yaml-import defined.
-  stale-devices:
-    status: exempt
-    comment: Each config entry, represents one service.
-
-  # Platinum
-  async-dependency:
-    status: todo
-    comment: feedparser lib is not async.
-  inject-websession:
-    status: todo
-    comment: feedparser lib doesn't take a session as argument.
-  strict-typing:
-    status: todo
-    comment: feedparser lib is not fully typed.

homeassistant/components/feedreader/strings.json

@@ -21,6 +21,12 @@
       }
     }
   },
+  "issues": {
+    "import_yaml_error_url_error": {
+      "description": "Configuring the Feedreader using YAML is being removed but there was a connection error when trying to import the YAML configuration for `{url}`.\n\nPlease verify that the URL is reachable and accessible for Home Assistant and restart Home Assistant to try again or remove the Feedreader YAML configuration from your configuration.yaml file and continue to set up the integration manually.",
+      "title": "The Feedreader YAML configuration import failed"
+    }
+  },
   "options": {
     "step": {
       "init": {

homeassistant/components/firefly_iii/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["pyfirefly==0.1.10"]
+  "requirements": ["pyfirefly==0.1.8"]
 }

homeassistant/components/fish_audio/__init__.py

@@ -1,51 +0,0 @@
-"""The Fish Audio integration."""
-
-from __future__ import annotations
-
-import logging
-
-from fishaudio import AsyncFishAudio
-from fishaudio.exceptions import AuthenticationError, FishAudioError
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-
-from .const import CONF_API_KEY
-from .types import FishAudioConfigEntry
-
-_LOGGER = logging.getLogger(__name__)
-
-PLATFORMS: list[Platform] = [Platform.TTS]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: FishAudioConfigEntry) -> bool:
-    """Set up Fish Audio from a config entry."""
-    client = AsyncFishAudio(api_key=entry.data[CONF_API_KEY])
-
-    try:
-        # Validate API key by getting account credits.
-        await client.account.get_credits()
-    except AuthenticationError as exc:
-        raise ConfigEntryAuthFailed(f"Invalid API key: {exc}") from exc
-    except FishAudioError as exc:
-        raise ConfigEntryNotReady(f"Error connecting to Fish Audio: {exc}") from exc
-
-    entry.runtime_data = client
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
-
-    return True
-
-
-async def _async_update_listener(
-    hass: HomeAssistant, entry: FishAudioConfigEntry
-) -> None:
-    """Handle options update."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: FishAudioConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/fish_audio/config_flow.py

@@ -1,352 +0,0 @@
-"""Config flow for the Fish Audio integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from fishaudio import AsyncFishAudio
-from fishaudio.exceptions import AuthenticationError, FishAudioError
-import voluptuous as vol
-
-from homeassistant.config_entries import (
-    SOURCE_USER,
-    ConfigEntry,
-    ConfigEntryState,
-    ConfigFlow,
-    ConfigFlowResult,
-    ConfigSubentryFlow,
-    SubentryFlowResult,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.selector import (
-    LanguageSelector,
-    LanguageSelectorConfig,
-    SelectOptionDict,
-    SelectSelector,
-    SelectSelectorConfig,
-    SelectSelectorMode,
-)
-
-from .const import (
-    API_KEYS_URL,
-    BACKEND_MODELS,
-    CONF_API_KEY,
-    CONF_BACKEND,
-    CONF_LANGUAGE,
-    CONF_LATENCY,
-    CONF_NAME,
-    CONF_SELF_ONLY,
-    CONF_SORT_BY,
-    CONF_TITLE,
-    CONF_USER_ID,
-    CONF_VOICE_ID,
-    DOMAIN,
-    LATENCY_OPTIONS,
-    SIGNUP_URL,
-    SORT_BY_OPTIONS,
-    TTS_SUPPORTED_LANGUAGES,
-)
-from .error import (
-    CannotConnectError,
-    CannotGetModelsError,
-    InvalidAuthError,
-    UnexpectedError,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def get_api_key_schema(default: str | None = None) -> vol.Schema:
-    """Return the schema for API key input."""
-    return vol.Schema(
-        {vol.Required(CONF_API_KEY, default=default or vol.UNDEFINED): str}
-    )
-
-
-def get_filter_schema(options: dict[str, Any]) -> vol.Schema:
-    """Return the schema for the filter step."""
-    return vol.Schema(
-        {
-            vol.Optional(CONF_TITLE, default=options.get(CONF_TITLE, "")): str,
-            vol.Optional(
-                CONF_LANGUAGE, default=options.get(CONF_LANGUAGE, "Any")
-            ): LanguageSelector(
-                LanguageSelectorConfig(
-                    languages=TTS_SUPPORTED_LANGUAGES,
-                )
-            ),
-            vol.Optional(
-                CONF_SORT_BY, default=options.get(CONF_SORT_BY, "task_count")
-            ): SelectSelector(
-                SelectSelectorConfig(
-                    options=SORT_BY_OPTIONS,
-                    mode=SelectSelectorMode.DROPDOWN,
-                    translation_key="sort_by",
-                )
-            ),
-            vol.Optional(
-                CONF_SELF_ONLY, default=options.get(CONF_SELF_ONLY, False)
-            ): bool,
-        }
-    )
-
-
-def get_model_selection_schema(
-    options: dict[str, Any],
-    model_options: list[SelectOptionDict],
-) -> vol.Schema:
-    """Return the schema for the model selection step."""
-    return vol.Schema(
-        {
-            vol.Required(
-                CONF_VOICE_ID,
-                default=options.get(CONF_VOICE_ID, ""),
-            ): SelectSelector(
-                SelectSelectorConfig(
-                    options=model_options,
-                    mode=SelectSelectorMode.DROPDOWN,
-                    custom_value=True,
-                )
-            ),
-            vol.Required(
-                CONF_BACKEND,
-                default=options.get(CONF_BACKEND, "s1"),
-            ): SelectSelector(
-                SelectSelectorConfig(
-                    options=[
-                        SelectOptionDict(value=opt, label=opt) for opt in BACKEND_MODELS
-                    ],
-                    mode=SelectSelectorMode.DROPDOWN,
-                )
-            ),
-            vol.Required(
-                CONF_LATENCY,
-                default=options.get(CONF_LATENCY, "balanced"),
-            ): SelectSelector(
-                SelectSelectorConfig(
-                    options=[
-                        SelectOptionDict(value=opt, label=opt)
-                        for opt in LATENCY_OPTIONS
-                    ],
-                    mode=SelectSelectorMode.DROPDOWN,
-                )
-            ),
-            vol.Required(
-                CONF_NAME,
-                default=options.get(CONF_NAME) or vol.UNDEFINED,
-            ): str,
-        }
-    )
-
-
-async def _validate_api_key(
-    hass: HomeAssistant, api_key: str
-) -> tuple[str, AsyncFishAudio]:
-    """Validate the user input allows us to connect."""
-    client = AsyncFishAudio(api_key=api_key)
-
-    try:
-        # Validate API key and get user info
-        credit_info = await client.account.get_credits()
-        user_id = credit_info.user_id
-    except AuthenticationError as exc:
-        raise InvalidAuthError(exc) from exc
-    except FishAudioError as exc:
-        raise CannotConnectError(exc) from exc
-    except Exception as exc:
-        raise UnexpectedError(exc) from exc
-
-    return user_id, client
-
-
-class FishAudioConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Fish Audio."""
-
-    VERSION = 1
-    client: AsyncFishAudio | None
-
-    def __init__(self) -> None:
-        """Initialize the config flow."""
-        self.client = None
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        if user_input is None:
-            return self.async_show_form(
-                step_id="user",
-                data_schema=get_api_key_schema(),
-                errors={},
-                description_placeholders={"signup_url": SIGNUP_URL},
-            )
-
-        errors: dict[str, str] = {}
-
-        try:
-            user_id, self.client = await _validate_api_key(
-                self.hass, user_input[CONF_API_KEY]
-            )
-        except InvalidAuthError:
-            errors["base"] = "invalid_auth"
-        except CannotConnectError:
-            errors["base"] = "cannot_connect"
-        except UnexpectedError:
-            errors["base"] = "unknown"
-        else:
-            await self.async_set_unique_id(user_id)
-            self._abort_if_unique_id_configured()
-
-            data: dict[str, Any] = {
-                CONF_API_KEY: user_input[CONF_API_KEY],
-                CONF_USER_ID: user_id,
-            }
-
-            return self.async_create_entry(
-                title="Fish Audio",
-                data=data,
-            )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=get_api_key_schema(),
-            errors=errors,
-            description_placeholders={
-                "signup_url": SIGNUP_URL,
-                "api_keys_url": API_KEYS_URL,
-            },
-        )
-
-    @classmethod
-    @callback
-    def async_get_supported_subentry_types(
-        cls, config_entry: ConfigEntry
-    ) -> dict[str, type]:
-        """Return subentries supported by this integration."""
-        return {"tts": FishAudioSubentryFlowHandler}
-
-
-class FishAudioSubentryFlowHandler(ConfigSubentryFlow):
-    """Handle subentry flow for adding and modifying a tts entity."""
-
-    config_data: dict[str, Any]
-    models: list[SelectOptionDict]
-    client: AsyncFishAudio
-
-    def __init__(self) -> None:
-        """Initialize the subentry flow handler."""
-        super().__init__()
-        self.models: list[SelectOptionDict] = []
-
-    async def _async_get_models(
-        self, self_only: bool, language: str | None, title: str | None, sort_by: str
-    ) -> list[SelectOptionDict]:
-        """Get the available models."""
-        try:
-            voices_response = await self.client.voices.list(
-                self_only=self_only,
-                language=language
-                if language and language.strip() and language != "Any"
-                else None,
-                title=title if title and title.strip() else None,
-                sort_by=sort_by,
-            )
-        except Exception as exc:
-            raise CannotGetModelsError(exc) from exc
-
-        voices = voices_response.items
-
-        return [
-            SelectOptionDict(
-                value=voice.id,
-                label=f"{voice.title} - {voice.task_count} uses",
-            )
-            for voice in voices
-        ]
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle the initial step."""
-        self.config_data = {}
-        return await self.async_step_init()
-
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle reconfiguration of a subentry."""
-        self.config_data = dict(self._get_reconfigure_subentry().data)
-        return await self.async_step_init()
-
-    async def async_step_init(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Manage initial options."""
-        entry = self._get_entry()
-        if entry.state != ConfigEntryState.LOADED:
-            return self.async_abort(reason="entry_not_loaded")
-
-        self.client = entry.runtime_data
-
-        if user_input is not None:
-            self.config_data.update(user_input)
-            return await self.async_step_model()
-
-        return self.async_show_form(
-            step_id="init",
-            data_schema=get_filter_schema(self.config_data),
-            errors={},
-        )
-
-    async def async_step_model(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle the model selection step."""
-        errors: dict[str, str] = {}
-
-        if not self.models:
-            try:
-                self.models = await self._async_get_models(
-                    self_only=self.config_data.get(CONF_SELF_ONLY, False),
-                    language=self.config_data.get(CONF_LANGUAGE),
-                    title=self.config_data.get(CONF_TITLE),
-                    sort_by=self.config_data.get(CONF_SORT_BY, "task_count"),
-                )
-            except CannotGetModelsError:
-                return self.async_abort(reason="cannot_connect")
-
-            if not self.models:
-                return self.async_abort(reason="no_models_found")
-
-            if CONF_VOICE_ID not in self.config_data and self.models:
-                self.config_data[CONF_VOICE_ID] = self.models[0]["value"]
-
-        if user_input is not None:
-            if (
-                (voice_id := user_input.get(CONF_VOICE_ID))
-                and (backend := user_input.get(CONF_BACKEND))
-                and (name := user_input.get(CONF_NAME))
-            ):
-                self.config_data.update(user_input)
-                unique_id = f"{voice_id}-{backend}"
-
-                if self.source == SOURCE_USER:
-                    return self.async_create_entry(
-                        title=name,
-                        data=self.config_data,
-                        unique_id=unique_id,
-                    )
-
-                return self.async_update_and_abort(
-                    self._get_entry(),
-                    self._get_reconfigure_subentry(),
-                    data=self.config_data,
-                    unique_id=unique_id,
-                )
-
-        return self.async_show_form(
-            step_id="model",
-            data_schema=get_model_selection_schema(self.config_data, self.models),
-            errors=errors,
-        )

homeassistant/components/fish_audio/const.py

@@ -1,40 +0,0 @@
-"""Constants for the FishAudio integration."""
-
-from typing import Literal
-
-DOMAIN = "fish_audio"
-
-
-CONF_NAME: Literal["name"] = "name"
-CONF_USER_ID: Literal["user_id"] = "user_id"
-CONF_API_KEY: Literal["api_key"] = "api_key"
-CONF_VOICE_ID: Literal["voice_id"] = "voice_id"
-CONF_BACKEND: Literal["backend"] = "backend"
-CONF_SELF_ONLY: Literal["self_only"] = "self_only"
-CONF_LANGUAGE: Literal["language"] = "language"
-CONF_SORT_BY: Literal["sort_by"] = "sort_by"
-CONF_LATENCY: Literal["latency"] = "latency"
-CONF_TITLE: Literal["title"] = "title"
-
-DEVELOPER_ID = "1e9f9baadce144f5b16dd94cbc0314c8"
-
-TTS_SUPPORTED_LANGUAGES = [
-    "Any",
-    "en",
-    "zh",
-    "de",
-    "ja",
-    "ar",
-    "fr",
-    "es",
-    "ko",
-]
-
-
-BACKEND_MODELS = ["s1", "speech-1.5", "speech-1.6"]
-SORT_BY_OPTIONS = ["task_count", "score", "created_at"]
-LATENCY_OPTIONS = ["normal", "balanced"]
-
-SIGNUP_URL = "https://fish.audio/?fpr=homeassistant"  # codespell:ignore fpr
-BILLING_URL = "https://fish.audio/app/billing/"
-API_KEYS_URL = "https://fish.audio/app/api-keys/"

homeassistant/components/fish_audio/error.py

@@ -1,52 +0,0 @@
-"""Exceptions for the Fish Audio integration."""
-
-import logging
-
-from homeassistant.exceptions import HomeAssistantError
-
-_LOGGER = logging.getLogger(__package__)
-
-
-class FishAudioError(HomeAssistantError):
-    """Base class for Fish Audio errors."""
-
-
-class CannotConnectError(FishAudioError):
-    """Error to indicate we cannot connect."""
-
-    def __init__(self, exc: Exception) -> None:
-        """Initialize the connection error."""
-        super().__init__("Cannot connect")
-
-
-class InvalidAuthError(FishAudioError):
-    """Error to indicate invalid authentication."""
-
-    def __init__(self, exc: Exception) -> None:
-        """Initialize the invalid auth error."""
-        super().__init__("Invalid authentication")
-
-
-class CannotGetModelsError(FishAudioError):
-    """Error to indicate we cannot get models."""
-
-    def __init__(self, exc: Exception) -> None:
-        """Initialize the model fetch error."""
-        super().__init__("Cannot get models")
-
-
-class UnexpectedError(FishAudioError):
-    """Error to indicate an unexpected error."""
-
-    def __init__(self, exc: Exception) -> None:
-        """Initialize and log the unexpected error."""
-        super().__init__("Unexpected error")
-        _LOGGER.exception("Unexpected exception: %s", exc)
-
-
-class AlreadyConfiguredError(FishAudioError):
-    """Error to indicate already configured."""
-
-    def __init__(self, exc: Exception) -> None:
-        """Initialize the already configured error."""
-        super().__init__("Already configured")

homeassistant/components/fish_audio/manifest.json

@@ -1,12 +0,0 @@
-{
-  "domain": "fish_audio",
-  "name": "Fish Audio",
-  "codeowners": ["@noambav"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/fish_audio",
-  "integration_type": "service",
-  "iot_class": "cloud_polling",
-  "loggers": ["fish_audio_sdk"],
-  "quality_scale": "bronze",
-  "requirements": ["fish-audio-sdk==1.1.0"]
-}

homeassistant/components/fish_audio/quality_scale.yaml

@@ -1,78 +0,0 @@
-rules:
-  # Bronze
-  action-setup: done
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow: done
-  config-flow-test-coverage: done
-  dependency-transparency: done
-  docs-actions: done
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: Entities in this integration do not 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
-  config-entry-unloading: done
-  log-when-unavailable: todo
-  entity-unavailable:
-    status: exempt
-    comment: TTS platform has no state to mark unavailable.
-  action-exceptions: done
-  reauthentication-flow: todo
-  parallel-updates: done
-  test-coverage: todo
-  integration-owner: done
-  docs-installation-parameters: todo
-  docs-configuration-parameters: todo
-
-  # Gold
-  entity-translations: todo
-  entity-device-class:
-    status: exempt
-    comment: No device class for TTS entities.
-  devices: done
-  entity-category: done
-  entity-disabled-by-default: todo
-  discovery:
-    status: exempt
-    comment: No physical device to discover.
-  stale-devices:
-    status: exempt
-    comment: No physical device.
-  diagnostics: todo
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow:
-    status: todo
-    comment: Could be useful if default voice disappears.
-  dynamic-devices:
-    status: exempt
-    comment: No physical device.
-  discovery-update-info:
-    status: exempt
-    comment: No physical device.
-  repair-issues: todo
-  docs-use-cases: done
-  docs-supported-devices:
-    status: exempt
-    comment: This integration does not support devices.
-  docs-supported-functions: todo
-  docs-data-update: todo
-  docs-known-limitations: todo
-  docs-troubleshooting: todo
-  docs-examples: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/fish_audio/strings.json

@@ -1,91 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]"
-    },
-    "error": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "cannot_connect": "Failed to connect, please check your API key and network connection.",
-      "invalid_auth": "Invalid authentication. Please check your API key. You can get your API key from [Fish Audio API Keys]({api_keys_url}).",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]"
-        },
-        "data_description": {
-          "api_key": "Your personal API key for accessing the Fish Audio service."
-        },
-        "description": "Enter your Fish Audio API key to begin.\n\nIf you don't have an account, you can sign up for a free one on [Fish Audio]({signup_url}).",
-        "title": "Connect to Fish Audio"
-      }
-    }
-  },
-  "config_subentries": {
-    "tts": {
-      "abort": {
-        "already_configured": "This TTS voice is already configured.",
-        "cannot_connect": "Failed to connect to Fish Audio",
-        "entry_not_loaded": "Cannot add TTS voice while the configuration is disabled.",
-        "no_models_found": "No voices found matching the specified filters. Please adjust your filters and try again.",
-        "reconfigure_successful": "Your TTS voice has been updated successfully. The integration will now reload with the new settings."
-      },
-      "entry_type": "TTS voice",
-      "error": {
-        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-        "no_model_selected": "You must select a voice to continue.",
-        "no_models_found": "No voices found matching the specified filters."
-      },
-      "initiate_flow": {
-        "reconfigure": "Reconfigure TTS voice",
-        "user": "Add TTS voice"
-      },
-      "step": {
-        "init": {
-          "data": {
-            "language": "Filter by language",
-            "self_only": "Show only my private voices",
-            "sort_by": "Sort voices by",
-            "title": "Filter by name"
-          },
-          "data_description": {
-            "language": "Display only voices that support the selected language.",
-            "self_only": "When checked, this will only show the voices you have personally created or cloned.",
-            "sort_by": "Choose the order in which the voices are displayed.",
-            "title": "Filter voices by name."
-          },
-          "description": "Apply filters to narrow down the voice list, then click Submit to see the results.",
-          "title": "Voice selection filters"
-        },
-        "model": {
-          "data": {
-            "backend": "AI voice model",
-            "latency": "Latency mode",
-            "name": "[%key:common::config_flow::data::name%]",
-            "voice_id": "Voice"
-          },
-          "data_description": {
-            "backend": "Select the AI model that will generate the audio.",
-            "latency": "Choose the latency mode: 'normal' for standard processing or 'balanced' for optimized speed.",
-            "name": "Enter a unique name for this TTS voice to easily identify it in Home Assistant.",
-            "voice_id": "Choose from the list of available voices, or manually enter a specific voice ID."
-          },
-          "description": "Select your preferred voice and the AI model to use for speech synthesis.",
-          "title": "Choose your voice and model"
-        }
-      }
-    }
-  },
-  "selector": {
-    "sort_by": {
-      "options": {
-        "created_at": "Newest",
-        "score": "Highest score",
-        "task_count": "Most uses"
-      }
-    }
-  }
-}

homeassistant/components/fish_audio/tts.py

@@ -1,122 +0,0 @@
-"""TTS platform for the Fish Audio integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from fishaudio.exceptions import APIError, RateLimitError
-
-from homeassistant.components.tts import TextToSpeechEntity, TtsAudioType
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import FishAudioConfigEntry
-from .const import (
-    CONF_BACKEND,
-    CONF_LATENCY,
-    CONF_VOICE_ID,
-    DOMAIN,
-    TTS_SUPPORTED_LANGUAGES,
-)
-from .error import UnexpectedError
-
-PARALLEL_UPDATES = 1
-_LOGGER = logging.getLogger(__name__)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: FishAudioConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Fish Audio TTS platform."""
-    _LOGGER.debug("Setting up Fish Audio TTS platform")
-
-    _LOGGER.debug("Entry: %s", entry)
-    # Iterate over values
-    for subentry in entry.subentries.values():
-        _LOGGER.debug("Subentry: %s", subentry)
-        if subentry.subentry_type != "tts":
-            continue
-        async_add_entities(
-            [FishAudioTTSEntity(entry, subentry)],
-            config_subentry_id=subentry.subentry_id,
-        )
-
-
-class FishAudioTTSEntity(TextToSpeechEntity):
-    """Fish Audio TTS entity."""
-
-    _attr_has_entity_name = True
-    _attr_supported_options = [CONF_VOICE_ID, CONF_BACKEND, CONF_LATENCY]
-
-    def __init__(self, entry: FishAudioConfigEntry, sub_entry: ConfigSubentry) -> None:
-        """Initialize the TTS entity."""
-        self.client = entry.runtime_data
-        self.sub_entry = sub_entry
-        self._attr_unique_id = sub_entry.subentry_id
-        title = sub_entry.title
-        backend = sub_entry.data[CONF_BACKEND]
-        self._attr_name = title
-
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, sub_entry.subentry_id)},
-            manufacturer="Fish Audio",
-            model=backend,
-            name=title,
-            entry_type=DeviceEntryType.SERVICE,
-        )
-
-    @property
-    def default_language(self) -> str:
-        """Return the default language."""
-        return "en"
-
-    @property
-    def supported_languages(self) -> list[str]:
-        """Return a list of supported languages."""
-        return TTS_SUPPORTED_LANGUAGES
-
-    async def async_get_tts_audio(
-        self,
-        message: str,
-        language: str,
-        options: dict[str, Any],
-    ) -> TtsAudioType:
-        """Load tts audio file from engine."""
-
-        _LOGGER.debug("Getting TTS audio for %s", message)
-
-        voice_id = options.get(CONF_VOICE_ID, self.sub_entry.data.get(CONF_VOICE_ID))
-        backend = options.get(CONF_BACKEND, self.sub_entry.data.get(CONF_BACKEND))
-        latency = options.get(
-            CONF_LATENCY, self.sub_entry.data.get(CONF_LATENCY, "balanced")
-        )
-
-        if voice_id is None:
-            raise ServiceValidationError("Voice ID not configured")
-        if backend is None:
-            raise ServiceValidationError("Backend model not configured")
-
-        try:
-            audio = await self.client.tts.convert(
-                text=message,
-                reference_id=voice_id,
-                latency=latency,
-                model=backend,
-                format="mp3",
-            )
-        except RateLimitError as err:
-            _LOGGER.error("Fish Audio TTS rate limited: %s", err)
-            raise HomeAssistantError(f"Rate limited: {err}") from err
-        except APIError as err:
-            _LOGGER.error("Fish Audio TTS request failed: %s", err)
-            raise HomeAssistantError(f"TTS request failed: {err}") from err
-        except Exception as err:
-            raise UnexpectedError(err) from err
-
-        return "mp3", audio

homeassistant/components/fish_audio/types.py

@@ -1,9 +0,0 @@
-"""Type definitions for the Fish Audio integration."""
-
-from __future__ import annotations
-
-from fishaudio import AsyncFishAudio
-
-from homeassistant.config_entries import ConfigEntry
-
-type FishAudioConfigEntry = ConfigEntry[AsyncFishAudio]

homeassistant/components/fluss/__init__.py

@@ -1,31 +0,0 @@
-"""The Fluss+ integration."""
-
-from __future__ import annotations
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY, Platform
-from homeassistant.core import HomeAssistant
-
-from .coordinator import FlussDataUpdateCoordinator
-
-PLATFORMS: list[Platform] = [Platform.BUTTON]
-
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: FlussConfigEntry,
-) -> bool:
-    """Set up Fluss+ from a config entry."""
-    coordinator = FlussDataUpdateCoordinator(hass, entry, entry.data[CONF_API_KEY])
-    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: FlussConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/fluss/button.py

@@ -1,40 +0,0 @@
-"""Support for Fluss Devices."""
-
-from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import FlussApiClientError, FlussDataUpdateCoordinator
-from .entity import FlussEntity
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: FlussConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Fluss Devices, filtering out any invalid payloads."""
-    coordinator = entry.runtime_data
-    devices = coordinator.data
-
-    async_add_entities(
-        FlussButton(coordinator, device_id, device)
-        for device_id, device in devices.items()
-    )
-
-
-class FlussButton(FlussEntity, ButtonEntity):
-    """Representation of a Fluss button device."""
-
-    _attr_name = None
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        try:
-            await self.coordinator.api.async_trigger_device(self.device_id)
-        except FlussApiClientError as err:
-            raise HomeAssistantError(f"Failed to trigger device: {err}") from err

homeassistant/components/fluss/config_flow.py

@@ -1,55 +0,0 @@
-"""Config flow for Fluss+ integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from fluss_api import (
-    FlussApiClient,
-    FlussApiClientAuthenticationError,
-    FlussApiClientCommunicationError,
-)
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN, LOGGER
-
-STEP_USER_DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): cv.string})
-
-
-class FlussConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Fluss+."""
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            api_key = user_input[CONF_API_KEY]
-            self._async_abort_entries_match({CONF_API_KEY: api_key})
-            client = FlussApiClient(
-                user_input[CONF_API_KEY], session=async_get_clientsession(self.hass)
-            )
-            try:
-                await client.async_get_devices()
-            except FlussApiClientCommunicationError:
-                errors["base"] = "cannot_connect"
-            except FlussApiClientAuthenticationError:
-                errors["base"] = "invalid_auth"
-            except Exception:  # noqa: BLE001
-                LOGGER.exception("Unexpected exception occurred")
-                errors["base"] = "unknown"
-            if not errors:
-                return self.async_create_entry(
-                    title="My Fluss+ Devices", data=user_input
-                )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/fluss/const.py

@@ -1,9 +0,0 @@
-"""Constants for the Fluss+ integration."""
-
-from datetime import timedelta
-import logging
-
-DOMAIN = "fluss"
-LOGGER = logging.getLogger(__name__)
-UPDATE_INTERVAL = 60  # seconds
-UPDATE_INTERVAL_TIMEDELTA = timedelta(seconds=UPDATE_INTERVAL)

homeassistant/components/fluss/coordinator.py

@@ -1,50 +0,0 @@
-"""DataUpdateCoordinator for Fluss+ integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from fluss_api import (
-    FlussApiClient,
-    FlussApiClientAuthenticationError,
-    FlussApiClientError,
-)
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from homeassistant.util import slugify
-
-from .const import LOGGER, UPDATE_INTERVAL_TIMEDELTA
-
-type FlussConfigEntry = ConfigEntry[FlussDataUpdateCoordinator]
-
-
-class FlussDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
-    """Manages fetching Fluss device data on a schedule."""
-
-    def __init__(
-        self, hass: HomeAssistant, config_entry: FlussConfigEntry, api_key: str
-    ) -> None:
-        """Initialize the coordinator."""
-        self.api = FlussApiClient(api_key, session=async_get_clientsession(hass))
-        super().__init__(
-            hass,
-            LOGGER,
-            name=f"Fluss+ ({slugify(api_key[:8])})",
-            config_entry=config_entry,
-            update_interval=UPDATE_INTERVAL_TIMEDELTA,
-        )
-
-    async def _async_update_data(self) -> dict[str, dict[str, Any]]:
-        """Fetch data from the Fluss API and return as a dictionary keyed by deviceId."""
-        try:
-            devices = await self.api.async_get_devices()
-        except FlussApiClientAuthenticationError as err:
-            raise ConfigEntryError(f"Authentication failed: {err}") from err
-        except FlussApiClientError as err:
-            raise UpdateFailed(f"Error fetching Fluss devices: {err}") from err
-
-        return {device["deviceId"]: device for device in devices.get("devices", [])}

homeassistant/components/fluss/entity.py

@@ -1,39 +0,0 @@
-"""Base entities for the Fluss+ integration."""
-
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .coordinator import FlussDataUpdateCoordinator
-
-
-class FlussEntity(CoordinatorEntity[FlussDataUpdateCoordinator]):
-    """Base class for Fluss entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: FlussDataUpdateCoordinator,
-        device_id: str,
-        device: dict,
-    ) -> None:
-        """Initialize the entity with a device ID and device data."""
-        super().__init__(coordinator)
-        self.device_id = device_id
-        self._attr_unique_id = device_id
-        self._attr_device_info = DeviceInfo(
-            identifiers={("fluss", device_id)},
-            name=device.get("deviceName"),
-            manufacturer="Fluss",
-            model="Fluss+ Device",
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return if the device is available."""
-        return super().available and self.device_id in self.coordinator.data
-
-    @property
-    def device(self) -> dict:
-        """Return the stored device data."""
-        return self.coordinator.data[self.device_id]

homeassistant/components/fluss/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "fluss",
-  "name": "Fluss+",
-  "codeowners": ["@fluss"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/fluss",
-  "iot_class": "cloud_polling",
-  "loggers": ["fluss-api"],
-  "quality_scale": "bronze",
-  "requirements": ["fluss-api==0.1.9.20"]
-}

homeassistant/components/fluss/quality_scale.yaml

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

homeassistant/components/fluss/strings.json

@@ -1,23 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]"
-        },
-        "data_description": {
-          "api_key": "The API key found in the profile page of the Fluss+ app."
-        },
-        "description": "Your Fluss API key, available in the profile page of the Fluss+ app"
-      }
-    }
-  }
-}

homeassistant/components/fressnapf_tracker/__init__.py

@@ -1,13 +1,12 @@
 """The Fressnapf Tracker integration."""
 
-from fressnapftracker import AuthClient, FressnapfTrackerAuthenticationError
+from fressnapftracker import AuthClient
 
 from homeassistant.const import CONF_ACCESS_TOKEN, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.httpx_client import get_async_client
 
-from .const import CONF_USER_ID, DOMAIN
+from .const import CONF_USER_ID
 from .coordinator import (
     FressnapfTrackerConfigEntry,
     FressnapfTrackerDataUpdateCoordinator,
@@ -27,16 +26,10 @@ async def async_setup_entry(
 ) -> bool:
     """Set up Fressnapf Tracker from a config entry."""
     auth_client = AuthClient(client=get_async_client(hass))
-    try:
-        devices = await auth_client.get_devices(
-            user_id=entry.data[CONF_USER_ID],
-            user_access_token=entry.data[CONF_ACCESS_TOKEN],
-        )
-    except FressnapfTrackerAuthenticationError as exception:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="invalid_auth",
-        ) from exception
+    devices = await auth_client.get_devices(
+        user_id=entry.data[CONF_USER_ID],
+        user_access_token=entry.data[CONF_ACCESS_TOKEN],
+    )
 
     coordinators: list[FressnapfTrackerDataUpdateCoordinator] = []
     for device in devices:

homeassistant/components/fressnapf_tracker/config_flow.py

@@ -1,6 +1,5 @@
 """Config flow for the Fressnapf Tracker integration."""
 
-from collections.abc import Mapping
 import logging
 from typing import Any
 
@@ -11,12 +10,7 @@ from fressnapftracker import (
 )
 import voluptuous as vol
 
-from homeassistant.config_entries import (
-    SOURCE_REAUTH,
-    SOURCE_RECONFIGURE,
-    ConfigFlow,
-    ConfigFlowResult,
-)
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_ACCESS_TOKEN
 from homeassistant.helpers.httpx_client import get_async_client
 
@@ -142,43 +136,40 @@ class FressnapfTrackerConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
-    async def _async_reauth_reconfigure(
-        self,
-        user_input: dict[str, Any] | None,
-        entry: Any,
-        step_id: str,
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Request a new sms code for reauth or reconfigure flows."""
+        """Handle reconfiguration of the integration."""
         errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
 
         if user_input is not None:
             errors, success = await self._async_request_sms_code(
                 user_input[CONF_PHONE_NUMBER]
             )
             if success:
-                if entry.data[CONF_USER_ID] != self._context[CONF_USER_ID]:
+                if reconfigure_entry.data[CONF_USER_ID] != self._context[CONF_USER_ID]:
                     errors["base"] = "account_change_not_allowed"
-                elif self.source == SOURCE_REAUTH:
-                    return await self.async_step_reauth_sms_code()
-                elif self.source == SOURCE_RECONFIGURE:
+                else:
                     return await self.async_step_reconfigure_sms_code()
 
         return self.async_show_form(
-            step_id=step_id,
-            data_schema=self.add_suggested_values_to_schema(
-                STEP_USER_DATA_SCHEMA,
-                {CONF_PHONE_NUMBER: entry.data.get(CONF_PHONE_NUMBER)},
+            step_id="reconfigure",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(
+                        CONF_PHONE_NUMBER,
+                        default=reconfigure_entry.data.get(CONF_PHONE_NUMBER),
+                    ): str,
+                }
             ),
             errors=errors,
         )
 
-    async def _async_reauth_reconfigure_sms_code(
-        self,
-        user_input: dict[str, Any] | None,
-        entry: Any,
-        step_id: str,
+    async def async_step_reconfigure_sms_code(
+        self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Verify SMS code for reauth or reconfigure flows."""
+        """Handle the SMS code step during reconfiguration."""
         errors: dict[str, str] = {}
 
         if user_input is not None:
@@ -187,61 +178,16 @@ class FressnapfTrackerConfigFlow(ConfigFlow, domain=DOMAIN):
             )
             if access_token:
                 return self.async_update_reload_and_abort(
-                    entry,
-                    data_updates={
+                    self._get_reconfigure_entry(),
+                    data={
                         CONF_PHONE_NUMBER: self._context[CONF_PHONE_NUMBER],
+                        CONF_USER_ID: self._context[CONF_USER_ID],
                         CONF_ACCESS_TOKEN: access_token,
                     },
                 )
 
         return self.async_show_form(
-            step_id=step_id,
+            step_id="reconfigure_sms_code",
             data_schema=STEP_SMS_CODE_DATA_SCHEMA,
             errors=errors,
         )
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle configuration by re-auth."""
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reauth confirmation step."""
-        return await self._async_reauth_reconfigure(
-            user_input,
-            self._get_reauth_entry(),
-            "reauth_confirm",
-        )
-
-    async def async_step_reauth_sms_code(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the SMS code step during reauth."""
-        return await self._async_reauth_reconfigure_sms_code(
-            user_input,
-            self._get_reauth_entry(),
-            "reauth_sms_code",
-        )
-
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration of the integration."""
-        return await self._async_reauth_reconfigure(
-            user_input,
-            self._get_reconfigure_entry(),
-            "reconfigure",
-        )
-
-    async def async_step_reconfigure_sms_code(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the SMS code step during reconfiguration."""
-        return await self._async_reauth_reconfigure_sms_code(
-            user_input,
-            self._get_reconfigure_entry(),
-            "reconfigure_sms_code",
-        )

homeassistant/components/fressnapf_tracker/coordinator.py

@@ -3,17 +3,10 @@
 from datetime import timedelta
 import logging
 
-from fressnapftracker import (
-    ApiClient,
-    Device,
-    FressnapfTrackerError,
-    FressnapfTrackerInvalidDeviceTokenError,
-    Tracker,
-)
+from fressnapftracker import ApiClient, Device, FressnapfTrackerError, Tracker
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -53,10 +46,5 @@ class FressnapfTrackerDataUpdateCoordinator(DataUpdateCoordinator[Tracker]):
     async def _async_update_data(self) -> Tracker:
         try:
             return await self.client.get_tracker()
-        except FressnapfTrackerInvalidDeviceTokenError as exception:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="invalid_auth",
-            ) from exception
         except FressnapfTrackerError as exception:
             raise UpdateFailed(exception) from exception

homeassistant/components/fressnapf_tracker/quality_scale.yaml

@@ -34,7 +34,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: done
+  reauthentication-flow: todo
   test-coverage: done
 
   # Gold

homeassistant/components/fressnapf_tracker/strings.json

@@ -2,7 +2,6 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
     },
     "error": {
@@ -12,23 +11,6 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
-      "reauth_confirm": {
-        "data": {
-          "phone_number": "[%key:component::fressnapf_tracker::config::step::user::data::phone_number%]"
-        },
-        "data_description": {
-          "phone_number": "[%key:component::fressnapf_tracker::config::step::user::data_description::phone_number%]"
-        },
-        "description": "Re-authenticate with your Fressnapf Tracker account to refresh your credentials."
-      },
-      "reauth_sms_code": {
-        "data": {
-          "sms_code": "[%key:component::fressnapf_tracker::config::step::sms_code::data::sms_code%]"
-        },
-        "data_description": {
-          "sms_code": "[%key:component::fressnapf_tracker::config::step::sms_code::data_description::sms_code%]"
-        }
-      },
       "reconfigure": {
         "data": {
           "phone_number": "[%key:component::fressnapf_tracker::config::step::user::data::phone_number%]"
@@ -36,7 +18,7 @@
         "data_description": {
           "phone_number": "[%key:component::fressnapf_tracker::config::step::user::data_description::phone_number%]"
         },
-        "description": "Update your Fressnapf Tracker account configuration."
+        "description": "Re-authenticate with your Fressnapf Tracker account to refresh your credentials."
       },
       "reconfigure_sms_code": {
         "data": {
@@ -80,9 +62,6 @@
     "charging": {
       "message": "The flashlight cannot be activated while charging."
     },
-    "invalid_auth": {
-      "message": "Your authentication with the Fressnapf Tracker API expired. Please re-authenticate to refresh your credentials."
-    },
     "low_battery": {
       "message": "The flashlight cannot be activated due to low battery."
     },

homeassistant/components/frontend/__init__.py

@@ -25,7 +25,7 @@ from homeassistant.const import (
     EVENT_PANELS_UPDATED,
     EVENT_THEMES_UPDATED,
 )
-from homeassistant.core import HomeAssistant, ServiceCall, async_get_hass, callback
+from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, service
 from homeassistant.helpers.icon import async_get_icons
@@ -41,7 +41,6 @@ from .storage import async_setup_frontend_storage
 _LOGGER = logging.getLogger(__name__)
 
 DOMAIN = "frontend"
-CONF_NAME_DARK = "name_dark"
 CONF_THEMES = "themes"
 CONF_THEMES_MODES = "modes"
 CONF_THEMES_LIGHT = "light"
@@ -527,16 +526,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     return True
 
 
-def _validate_selected_theme(theme: str) -> str:
-    """Validate that a user selected theme is a valid theme."""
-    if theme in (DEFAULT_THEME, VALUE_NO_THEME):
-        return theme
-    hass = async_get_hass()
-    if theme not in hass.data[DATA_THEMES]:
-        raise vol.Invalid(f"Theme {theme} not found")
-    return theme
-
-
 async def _async_setup_themes(
     hass: HomeAssistant, themes: dict[str, Any] | None
 ) -> None:
@@ -580,32 +569,27 @@ async def _async_setup_themes(
     @callback
     def set_theme(call: ServiceCall) -> None:
         """Set backend-preferred theme."""
+        name = call.data[CONF_NAME]
+        mode = call.data.get("mode", "light")
 
-        def _update_hass_theme(theme: str, light: bool) -> None:
-            theme_key = DATA_DEFAULT_THEME if light else DATA_DEFAULT_DARK_THEME
-            if theme == VALUE_NO_THEME:
-                to_set = DEFAULT_THEME if light else None
-            else:
-                _LOGGER.info(
-                    "Theme %s set as default %s theme",
-                    theme,
-                    "light" if light else "dark",
-                )
-                to_set = theme
-            hass.data[theme_key] = to_set
+        if (
+            name not in (DEFAULT_THEME, VALUE_NO_THEME)
+            and name not in hass.data[DATA_THEMES]
+        ):
+            _LOGGER.warning("Theme %s not found", name)
+            return
 
-        name = call.data.get(CONF_NAME)
-        if name is not None and CONF_MODE in call.data:
-            mode = call.data.get("mode", "light")
-            light_mode = mode == "light"
-            _update_hass_theme(name, light_mode)
+        light_mode = mode == "light"
+
+        theme_key = DATA_DEFAULT_THEME if light_mode else DATA_DEFAULT_DARK_THEME
+
+        if name == VALUE_NO_THEME:
+            to_set = DEFAULT_THEME if light_mode else None
         else:
-            name_dark = call.data.get(CONF_NAME_DARK)
-            if name:
-                _update_hass_theme(name, True)
-            if name_dark:
-                _update_hass_theme(name_dark, False)
+            _LOGGER.info("Theme %s set as default %s theme", name, mode)
+            to_set = name
 
+        hass.data[theme_key] = to_set
         store.async_delay_save(
             lambda: {
                 DATA_DEFAULT_THEME: hass.data[DATA_DEFAULT_THEME],
@@ -640,13 +624,11 @@ async def _async_setup_themes(
         DOMAIN,
         SERVICE_SET_THEME,
         set_theme,
-        vol.All(
+        vol.Schema(
             {
-                vol.Optional(CONF_NAME): _validate_selected_theme,
-                vol.Exclusive(CONF_NAME_DARK, "dark_modes"): _validate_selected_theme,
-                vol.Exclusive(CONF_MODE, "dark_modes"): vol.Any("dark", "light"),
-            },
-            cv.has_at_least_one_key(CONF_NAME, CONF_NAME_DARK),
+                vol.Required(CONF_NAME): cv.string,
+                vol.Optional(CONF_MODE): vol.Any("dark", "light"),
+            }
         ),
     )