[pull] dev from home-assistant:dev

.pre-commit-config.yaml

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

.strict-typing

@@ -169,6 +169,7 @@ homeassistant.components.dnsip.*
 homeassistant.components.doorbird.*
 homeassistant.components.dormakaba_dkey.*
 homeassistant.components.downloader.*
+homeassistant.components.droplet.*
 homeassistant.components.dsmr.*
 homeassistant.components.duckdns.*
 homeassistant.components.dunehd.*
@@ -401,6 +402,7 @@ homeassistant.components.person.*
 homeassistant.components.pi_hole.*
 homeassistant.components.ping.*
 homeassistant.components.plugwise.*
+homeassistant.components.portainer.*
 homeassistant.components.powerfox.*
 homeassistant.components.powerwall.*
 homeassistant.components.private_ble_device.*

homeassistant/components/accuweather/config_flow.py

@@ -50,6 +50,7 @@ async def async_step_user(
                 await self.async_set_unique_id(
                     accuweather.location_key, raise_on_progress=False
                 )
+                self._abort_if_unique_id_configured()
 
                 return self.async_create_entry(
                     title=user_input[CONF_NAME], data=user_input

homeassistant/components/accuweather/const.py

@@ -69,5 +69,5 @@
     4: "very_high",
     5: "extreme",
 }
-UPDATE_INTERVAL_OBSERVATION = timedelta(minutes=40)
+UPDATE_INTERVAL_OBSERVATION = timedelta(minutes=10)
 UPDATE_INTERVAL_DAILY_FORECAST = timedelta(hours=6)

homeassistant/components/accuweather/manifest.json

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

homeassistant/components/accuweather/strings.json

@@ -17,6 +17,9 @@
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_api_key": "[%key:common::config_flow::error::invalid_api_key%]",
       "requests_exceeded": "The allowed number of requests to the AccuWeather API has been exceeded. You have to wait or change the API key."
+    },
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_location%]"
     }
   },
   "entity": {

homeassistant/components/aladdin_connect/manifest.json

@@ -4,6 +4,11 @@
   "codeowners": ["@swcloudgenie"],
   "config_flow": true,
   "dependencies": ["application_credentials"],
+  "dhcp": [
+    {
+      "hostname": "gdocntl-*"
+    }
+  ],
   "documentation": "https://www.home-assistant.io/integrations/aladdin_connect",
   "integration_type": "hub",
   "iot_class": "cloud_polling",

homeassistant/components/aladdin_connect/strings.json

@@ -7,6 +7,9 @@
       "reauth_confirm": {
         "title": "[%key:common::config_flow::title::reauth%]",
         "description": "Aladdin Connect needs to re-authenticate your account"
+      },
+      "oauth_discovery": {
+        "description": "Home Assistant has found an Aladdin Connect device on your network. Press **Submit** to continue setting up Aladdin Connect."
       }
     },
     "abort": {

homeassistant/components/alexa_devices/coordinator.py

@@ -14,6 +14,7 @@
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import _LOGGER, CONF_LOGIN_DATA, DOMAIN
@@ -48,12 +49,13 @@ def __init__(
             entry.data[CONF_PASSWORD],
             entry.data[CONF_LOGIN_DATA],
         )
+        self.previous_devices: set[str] = set()
 
     async def _async_update_data(self) -> dict[str, AmazonDevice]:
         """Update device data."""
         try:
             await self.api.login_mode_stored_data()
-            return await self.api.get_devices_data()
+            data = await self.api.get_devices_data()
         except CannotConnect as err:
             raise UpdateFailed(
                 translation_domain=DOMAIN,
@@ -72,3 +74,31 @@ async def _async_update_data(self) -> dict[str, AmazonDevice]:
                 translation_key="invalid_auth",
                 translation_placeholders={"error": repr(err)},
             ) from err
+        else:
+            current_devices = set(data.keys())
+            if stale_devices := self.previous_devices - current_devices:
+                await self._async_remove_device_stale(stale_devices)
+
+            self.previous_devices = current_devices
+            return data
+
+    async def _async_remove_device_stale(
+        self,
+        stale_devices: set[str],
+    ) -> None:
+        """Remove stale device."""
+        device_registry = dr.async_get(self.hass)
+
+        for serial_num in stale_devices:
+            _LOGGER.debug(
+                "Detected change in devices: serial %s removed",
+                serial_num,
+            )
+            device = device_registry.async_get_device(
+                identifiers={(DOMAIN, serial_num)}
+            )
+            if device:
+                device_registry.async_update_device(
+                    device_id=device.id,
+                    remove_config_entry_id=self.config_entry.entry_id,
+                )

homeassistant/components/alexa_devices/quality_scale.yaml

@@ -64,9 +64,7 @@ rules:
   repair-issues:
     status: exempt
     comment: no known use cases for repair issues or flows, yet
-  stale-devices:
-    status: todo
-    comment: automate the cleanup process
+  stale-devices: done
 
   # Platinum
   async-dependency: done

homeassistant/components/deconz/sensor.py

@@ -99,7 +99,7 @@
 
 
 @dataclass(frozen=True, kw_only=True)
-class DeconzSensorDescription(Generic[T], SensorEntityDescription):
+class DeconzSensorDescription(SensorEntityDescription, Generic[T]):
     """Class describing deCONZ binary sensor entities."""
 
     instance_check: type[T] | None = None

homeassistant/components/droplet/__init__.py

@@ -0,0 +1,37 @@
+"""The Droplet integration."""
+
+from __future__ import annotations
+
+import logging
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import DropletConfigEntry, DropletDataCoordinator
+
+PLATFORMS: list[Platform] = [
+    Platform.SENSOR,
+]
+
+logger = logging.getLogger(__name__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, config_entry: DropletConfigEntry
+) -> bool:
+    """Set up Droplet from a config entry."""
+
+    droplet_coordinator = DropletDataCoordinator(hass, config_entry)
+    await droplet_coordinator.async_config_entry_first_refresh()
+    config_entry.runtime_data = droplet_coordinator
+    await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, config_entry: DropletConfigEntry
+) -> bool:
+    """Unload a config entry."""
+
+    return await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)

homeassistant/components/droplet/config_flow.py

@@ -0,0 +1,118 @@
+"""Config flow for Droplet integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydroplet.droplet import DropletConnection, DropletDiscovery
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_CODE, CONF_DEVICE_ID, CONF_IP_ADDRESS, CONF_PORT
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
+
+from .const import DOMAIN
+
+
+class DropletConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle Droplet config flow."""
+
+    _droplet_discovery: DropletDiscovery
+
+    async def async_step_zeroconf(
+        self, discovery_info: ZeroconfServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle zeroconf discovery."""
+        self._droplet_discovery = DropletDiscovery(
+            discovery_info.host,
+            discovery_info.port,
+            discovery_info.name,
+        )
+        if not self._droplet_discovery.is_valid():
+            return self.async_abort(reason="invalid_discovery_info")
+
+        # In this case, device ID was part of the zeroconf discovery info
+        device_id: str = await self._droplet_discovery.get_device_id()
+        await self.async_set_unique_id(device_id)
+
+        self._abort_if_unique_id_configured(
+            updates={CONF_IP_ADDRESS: self._droplet_discovery.host},
+        )
+
+        self.context.update({"title_placeholders": {"name": device_id}})
+        return await self.async_step_confirm()
+
+    async def async_step_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Confirm the setup."""
+        errors: dict[str, str] = {}
+        device_id: str = await self._droplet_discovery.get_device_id()
+        if user_input is not None:
+            # Test if we can connect before returning
+            session = async_get_clientsession(self.hass)
+            if await self._droplet_discovery.try_connect(
+                session, user_input[CONF_CODE]
+            ):
+                device_data = {
+                    CONF_IP_ADDRESS: self._droplet_discovery.host,
+                    CONF_PORT: self._droplet_discovery.port,
+                    CONF_DEVICE_ID: device_id,
+                    CONF_CODE: user_input[CONF_CODE],
+                }
+
+                return self.async_create_entry(
+                    title=device_id,
+                    data=device_data,
+                )
+            errors["base"] = "cannot_connect"
+        return self.async_show_form(
+            step_id="confirm",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_CODE): str,
+                }
+            ),
+            description_placeholders={
+                "device_name": device_id,
+            },
+            errors=errors,
+        )
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a flow initialized by the user."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            self._droplet_discovery = DropletDiscovery(
+                user_input[CONF_IP_ADDRESS], DropletConnection.DEFAULT_PORT, ""
+            )
+            session = async_get_clientsession(self.hass)
+            if await self._droplet_discovery.try_connect(
+                session, user_input[CONF_CODE]
+            ) and (device_id := await self._droplet_discovery.get_device_id()):
+                device_data = {
+                    CONF_IP_ADDRESS: self._droplet_discovery.host,
+                    CONF_PORT: self._droplet_discovery.port,
+                    CONF_DEVICE_ID: device_id,
+                    CONF_CODE: user_input[CONF_CODE],
+                }
+                await self.async_set_unique_id(device_id, raise_on_progress=False)
+                self._abort_if_unique_id_configured(
+                    description_placeholders={CONF_DEVICE_ID: device_id},
+                )
+
+                return self.async_create_entry(
+                    title=device_id,
+                    data=device_data,
+                )
+            errors["base"] = "cannot_connect"
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {vol.Required(CONF_IP_ADDRESS): str, vol.Required(CONF_CODE): str}
+            ),
+            errors=errors,
+        )

homeassistant/components/droplet/const.py

@@ -0,0 +1,11 @@
+"""Constants for the droplet integration."""
+
+CONNECT_DELAY = 5
+
+DOMAIN = "droplet"
+DEVICE_NAME = "Droplet"
+
+KEY_CURRENT_FLOW_RATE = "current_flow_rate"
+KEY_VOLUME = "volume"
+KEY_SIGNAL_QUALITY = "signal_quality"
+KEY_SERVER_CONNECTIVITY = "server_connectivity"