Add flow it integration

.strict-typing

@@ -215,6 +215,7 @@ homeassistant.components.filter.*
 homeassistant.components.firefly_iii.*
 homeassistant.components.fitbit.*
 homeassistant.components.flexit_bacnet.*
+homeassistant.components.flow_it.*
 homeassistant.components.flux_led.*
 homeassistant.components.folder_watcher.*
 homeassistant.components.forecast_solar.*

homeassistant/components/flow_it/__init__.py

@@ -0,0 +1,63 @@
+"""The Flow-it integration."""
+
+import logging
+
+from flow_it_api.client import FlowItVMCMachine
+from flow_it_api.models import MachineData
+
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.httpx_client import get_async_client
+
+from .coordinator import FlowItConfigEntry, FlowItCoordinator, FlowItData
+
+_LOGGER = logging.getLogger(__name__)
+
+
+PLATFORMS: list[Platform] = [
+    Platform.FAN,
+]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: FlowItConfigEntry) -> bool:
+    """Set up Flow-it from a config entry."""
+
+    vmc = FlowItVMCMachine(
+        entry.data[CONF_HOST],
+        entry.data[CONF_PASSWORD],
+        entry.data[CONF_USERNAME],
+        session=get_async_client(hass),
+    )
+
+    coordinator = FlowItCoordinator(hass, entry, vmc)
+
+    await coordinator.async_config_entry_first_refresh()
+
+    async def on_ws_data(data: MachineData) -> None:
+        """Handle data from WebSocket."""
+        _LOGGER.debug("Received WebSocket update")
+        if coordinator.data:
+            coordinator.data.state.data = data
+            coordinator.async_set_updated_data(coordinator.data)
+
+    vmc.register_websocket_callback(on_ws_data)
+    vmc.websocket.start()
+
+    entry.runtime_data = FlowItData(
+        vmc=vmc,
+        coordinator=coordinator,
+    )
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: FlowItConfigEntry) -> bool:
+    """Unload a config entry."""
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        vmc = entry.runtime_data.vmc
+        # Stop websocket and close client
+        await vmc.close()
+
+    return unload_ok

homeassistant/components/flow_it/config_flow.py

@@ -0,0 +1,184 @@
+"""Config flow for Flow-it integration."""
+
+import logging
+from typing import TYPE_CHECKING, Any, override
+
+from flow_it_api.client import FlowItVMCMachine
+from flow_it_api.exceptions import FlowItAuthError, FlowItConnectionError
+import voluptuous as vol
+from yarl import URL
+
+from homeassistant import config_entries
+from homeassistant.config_entries import ConfigFlowResult
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.helpers.selector import (
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
+)
+from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
+
+from .const import DEFAULT_USERNAME, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, Any]:
+    """Validate the user input allows us to connect."""
+    vmc = FlowItVMCMachine(
+        data[CONF_HOST],
+        data[CONF_PASSWORD],
+        data[CONF_USERNAME],
+        session=get_async_client(hass),
+    )
+    info = await vmc.get_info()
+    await vmc.refresh_state()
+    if TYPE_CHECKING:
+        assert vmc.state is not None
+    return {
+        "title": info.hostname,
+        "unique_id": vmc.state.name,
+    }
+
+
+class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Flow-it."""
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._discovery_info: dict[str, Any] = {}
+
+    @override
+    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:
+            host = user_input[CONF_HOST]
+
+            # Ensure host has protocol
+            if not URL(host).scheme:
+                host = str(URL.build(scheme="http", host=host))
+                user_input[CONF_HOST] = host
+
+            try:
+                info = await validate_input(self.hass, user_input)
+            except FlowItAuthError:
+                errors["base"] = "invalid_auth"
+            except FlowItConnectionError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                await self.async_set_unique_id(info["unique_id"])
+                self._abort_if_unique_id_configured(updates=user_input)
+                return self.async_create_entry(title=info["title"], data=user_input)
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_HOST): str,
+                    vol.Required(CONF_USERNAME, default=DEFAULT_USERNAME): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.TEXT, autocomplete="username"
+                        )
+                    ),
+                    vol.Required(CONF_PASSWORD): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.PASSWORD,
+                            autocomplete="current-password",
+                        )
+                    ),
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_zeroconf_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a flow initiated by zeroconf."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            host = self._discovery_info[CONF_HOST]
+            if not URL(host).scheme:
+                host = str(URL.build(scheme="http", host=host))
+
+            data = {
+                CONF_HOST: host,
+                CONF_USERNAME: user_input[CONF_USERNAME],
+                CONF_PASSWORD: user_input[CONF_PASSWORD],
+            }
+
+            try:
+                info = await validate_input(self.hass, data)
+            except FlowItAuthError:
+                errors["base"] = "invalid_auth"
+            except FlowItConnectionError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                await self.async_set_unique_id(info["unique_id"])
+                self._abort_if_unique_id_configured(updates=data)
+                return self.async_create_entry(
+                    title=info["title"],
+                    data=data,
+                )
+
+        data_schema = vol.Schema(
+            {
+                vol.Required(CONF_USERNAME, default=DEFAULT_USERNAME): TextSelector(
+                    TextSelectorConfig(
+                        type=TextSelectorType.TEXT, autocomplete="username"
+                    )
+                ),
+                vol.Required(CONF_PASSWORD): TextSelector(
+                    TextSelectorConfig(
+                        type=TextSelectorType.PASSWORD, autocomplete="current-password"
+                    )
+                ),
+            }
+        )
+
+        return self.async_show_form(
+            step_id="zeroconf_confirm",
+            data_schema=data_schema,
+            errors=errors,
+            description_placeholders={
+                "name": self._discovery_info.get(
+                    "friendly_name",
+                    self._discovery_info[CONF_HOST].removesuffix(".local"),
+                )
+            },
+        )
+
+    @override
+    async def async_step_zeroconf(
+        self, discovery_info: ZeroconfServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle zeroconf discovery."""
+        host = discovery_info.host
+        hostname = discovery_info.hostname.rstrip(".")
+        friendly_name = discovery_info.name.removesuffix("._tbk_vmc._tcp.local.")
+
+        self._discovery_info = {
+            CONF_HOST: hostname,
+            "friendly_name": friendly_name,
+        }
+
+        # Check if already configured
+        self._async_abort_entries_match({CONF_HOST: host})
+        self._async_abort_entries_match({CONF_HOST: hostname})
+        self._async_abort_entries_match({CONF_HOST: f"http://{host}"})
+        self._async_abort_entries_match({CONF_HOST: f"http://{hostname}"})
+
+        self.context.update({"title_placeholders": {"name": friendly_name}})
+
+        return await self.async_step_zeroconf_confirm()

homeassistant/components/flow_it/const.py

@@ -0,0 +1,6 @@
+"""Constants for the Flow-it integration."""
+
+DOMAIN = "flow_it"
+
+
+DEFAULT_USERNAME = "api"

homeassistant/components/flow_it/coordinator.py

@@ -0,0 +1,80 @@
+"""Data update coordinator for the Flow-it integration."""
+
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+from typing import override
+
+from flow_it_api.client import FlowItVMCMachine
+from flow_it_api.exceptions import (
+    FlowItAuthError,
+    FlowItConnectionError,
+    FlowItResponseError,
+)
+from flow_it_api.models import MachineStatusResponse
+
+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 .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+type FlowItConfigEntry = ConfigEntry[FlowItData]
+
+
+@dataclass(kw_only=True, frozen=True)
+class FlowItCoordinatorData:
+    """Data fetched from the Flow-it VMC."""
+
+    state: MachineStatusResponse
+
+
+@dataclass(kw_only=True, frozen=True)
+class FlowItData:
+    """Data for the Flow-it integration."""
+
+    vmc: FlowItVMCMachine
+    coordinator: FlowItCoordinator
+
+
+class FlowItCoordinator(DataUpdateCoordinator[FlowItCoordinatorData]):
+    """Class to manage fetching Flow-it data."""
+
+    config_entry: FlowItConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: ConfigEntry,
+        vmc: FlowItVMCMachine,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_interval=timedelta(seconds=30),
+            config_entry=config_entry,
+        )
+        self.vmc = vmc
+
+    @override
+    async def _async_update_data(self) -> FlowItCoordinatorData:
+        """Fetch data from API endpoint."""
+        try:
+            await self.vmc.refresh_state()
+        except FlowItAuthError as err:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="auth_failed",
+                translation_placeholders={"error": str(err)},
+            ) from err
+        except (FlowItConnectionError, FlowItResponseError) as err:
+            raise UpdateFailed(f"Error communicating with API: {err}") from err
+        else:
+            assert self.vmc.state is not None
+            return FlowItCoordinatorData(state=self.vmc.state)

homeassistant/components/flow_it/entity.py

@@ -0,0 +1,35 @@
+"""Base entity for Flow-it."""
+
+from flow_it_api.client import FlowItVMCMachine
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import FlowItCoordinator
+
+
+class FlowItVmcEntity(CoordinatorEntity[FlowItCoordinator]):
+    """Base entity for Flow-it."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: FlowItCoordinator,
+        vmc: FlowItVMCMachine,
+        entity_description: EntityDescription,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self.entity_description = entity_description
+        self.vmc = vmc
+        self._attr_unique_id = f"{coordinator.data.state.name}_{entity_description.key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, coordinator.data.state.name)},
+            name=coordinator.data.state.name,
+            manufacturer="FLOW-IT",
+            model="VMC",
+            sw_version=coordinator.data.state.data.alert.version,
+        )