Add integration for Droplet (#149989)

Co-authored-by: Norbert Rittel <[email protected]>
Co-authored-by: Josef Zweck <[email protected]>
Co-authored-by: Joost Lekkerkerker <[email protected]>

Author: 4 people

.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.*

CODEOWNERS

@@ -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/__init__.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/config_flow.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"

homeassistant/components/droplet/const.py

@@ -0,0 +1,84 @@
+"""Droplet device data update coordinator object."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+
+from pydroplet.droplet import Droplet
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_CODE, CONF_IP_ADDRESS, CONF_PORT
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import CONNECT_DELAY, DOMAIN
+
+VERSION_TIMEOUT = 5
+
+_LOGGER = logging.getLogger(__name__)
+
+TIMEOUT = 1
+
+type DropletConfigEntry = ConfigEntry[DropletDataCoordinator]
+
+
+class DropletDataCoordinator(DataUpdateCoordinator[None]):
+    """Droplet device object."""
+
+    config_entry: DropletConfigEntry
+
+    def __init__(self, hass: HomeAssistant, entry: DropletConfigEntry) -> None:
+        """Initialize the device."""
+        super().__init__(
+            hass, _LOGGER, config_entry=entry, name=f"{DOMAIN}-{entry.unique_id}"
+        )
+        self.droplet = Droplet(
+            host=entry.data[CONF_IP_ADDRESS],
+            port=entry.data[CONF_PORT],
+            token=entry.data[CONF_CODE],
+            session=async_get_clientsession(self.hass),
+            logger=_LOGGER,
+        )
+        assert entry.unique_id is not None
+        self.unique_id = entry.unique_id
+
+    async def _async_setup(self) -> None:
+        if not await self.setup():
+            raise ConfigEntryNotReady("Device is offline")
+
+        # Droplet should send its metadata within 5 seconds
+        end = time.time() + VERSION_TIMEOUT
+        while not self.droplet.version_info_available():
+            await asyncio.sleep(TIMEOUT)
+            if time.time() > end:
+                _LOGGER.warning("Failed to get version info from Droplet")
+                return
+
+    async def _async_update_data(self) -> None:
+        if not self.droplet.connected:
+            raise UpdateFailed(
+                translation_domain=DOMAIN, translation_key="connection_error"
+            )
+
+    async def setup(self) -> bool:
+        """Set up droplet client."""
+        self.config_entry.async_on_unload(self.droplet.stop_listening)
+        self.config_entry.async_create_background_task(
+            self.hass,
+            self.droplet.listen_forever(CONNECT_DELAY, self.async_set_updated_data),
+            "droplet-listen",
+        )
+        end = time.time() + CONNECT_DELAY
+        while time.time() < end:
+            if self.droplet.connected:
+                return True
+            await asyncio.sleep(TIMEOUT)
+        return False
+
+    def get_availability(self) -> bool:
+        """Retrieve Droplet's availability status."""
+        return self.droplet.get_availability()

homeassistant/components/droplet/coordinator.py

@@ -0,0 +1,15 @@
+{
+  "entity": {
+    "sensor": {
+      "current_flow_rate": {
+        "default": "mdi:chart-line"
+      },
+      "server_connectivity": {
+        "default": "mdi:web"
+      },
+      "signal_quality": {
+        "default": "mdi:waveform"
+      }
+    }
+  }
+}

homeassistant/components/droplet/icons.json

@@ -0,0 +1,11 @@
+{
+  "domain": "droplet",
+  "name": "Droplet",
+  "codeowners": ["@sarahseidman"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/droplet",
+  "iot_class": "local_push",
+  "quality_scale": "bronze",
+  "requirements": ["pydroplet==2.3.2"],
+  "zeroconf": ["_droplet._tcp.local."]
+}

homeassistant/components/droplet/manifest.json

@@ -0,0 +1,72 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      No custom actions defined
+  appropriate-polling:
+    status: exempt
+    comment: |
+      No polling
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  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: todo
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: todo
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: done
+  discovery: done
+  docs-data-update: done
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: done
+  docs-troubleshooting: todo
+  docs-use-cases: done
+  dynamic-devices: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: todo
+  inject-websession: done
+  strict-typing: done