Add IoTaWatt integration

CODEOWNERS

@@ -248,6 +248,7 @@ homeassistant/components/integration/* @dgomes
 homeassistant/components/intent/* @home-assistant/core
 homeassistant/components/intesishome/* @jnimmo
 homeassistant/components/ios/* @robbiet480
+homeassistant/components/iotawatt/* @gtdiehl
 homeassistant/components/iperf3/* @rohankapoorcom
 homeassistant/components/ipma/* @dgomes @abmantis
 homeassistant/components/ipp/* @ctalkington

homeassistant/components/iotawatt/__init__.py

@@ -0,0 +1,24 @@
+"""The iotawatt integration."""
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+
+from .const import DOMAIN
+from .coordinator import IotawattUpdater
+
+PLATFORMS = ("sensor",)
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up iotawatt from a config entry."""
+    coordinator = IotawattUpdater(hass, entry)
+    await coordinator.async_config_entry_first_refresh()
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
+    hass.config_entries.async_setup_platforms(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    hass.data[DOMAIN].pop(entry.entry_id)
+    return unload_ok

homeassistant/components/iotawatt/config_flow.py

@@ -0,0 +1,107 @@
+"""Config flow for iotawatt integration."""
+import json
+import logging
+
+import httpx
+from iotawattpy.iotawatt import Iotawatt
+import voluptuous as vol
+
+from homeassistant import config_entries, core, exceptions
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.helpers import httpx_client
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def validate_input(
+    hass: core.HomeAssistant, data: dict[str, str]
+) -> dict[str, str]:
+    """Validate the user input allows us to connect."""
+    iotawatt = Iotawatt(
+        "",
+        data[CONF_HOST],
+        httpx_client.get_async_client(hass),
+        data.get(CONF_USERNAME),
+        data.get(CONF_PASSWORD),
+    )
+    try:
+        is_connected = await iotawatt.connect()
+    except (KeyError, json.JSONDecodeError, httpx.HTTPError):
+        return {"base": "cannot_connect"}
+    except Exception:  # pylint: disable=broad-except
+        _LOGGER.exception("Unexpected exception")
+        return {"base": "unknown"}
+
+    if not is_connected:
+        return {"base": "invalid_auth"}
+
+    return {}
+
+
+class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for iotawatt."""
+
+    VERSION = 1
+
+    def __init__(self):
+        """Initialize."""
+        self._data = {}
+
+    async def async_step_user(self, user_input=None):
+        """Handle the initial step."""
+        if user_input is None:
+            user_input = {}
+
+        schema = vol.Schema(
+            {
+                vol.Required(CONF_HOST, default=user_input.get(CONF_HOST, "")): str,
+            }
+        )
+        if not user_input:
+            return self.async_show_form(step_id="user", data_schema=schema)
+
+        if not (errors := await validate_input(self.hass, user_input)):
+            return self.async_create_entry(title=user_input[CONF_HOST], data=user_input)
+
+        if errors == {"base": "invalid_auth"}:
+            self._data.update(user_input)
+            return await self.async_step_auth()
+
+        return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
+
+    async def async_step_auth(self, user_input=None):
+        """Authenticate user if authentication is enabled on the IoTaWatt device."""
+        if user_input is None:
+            user_input = {}
+
+        data_schema = vol.Schema(
+            {
+                vol.Required(
+                    CONF_USERNAME, default=user_input.get(CONF_USERNAME, "")
+                ): str,
+                vol.Required(
+                    CONF_PASSWORD, default=user_input.get(CONF_PASSWORD, "")
+                ): str,
+            }
+        )
+        if not user_input:
+            return self.async_show_form(step_id="auth", data_schema=data_schema)
+
+        data = {**self._data, **user_input}
+
+        if errors := await validate_input(self.hass, data):
+            return self.async_show_form(
+                step_id="auth", data_schema=data_schema, errors=errors
+            )
+
+        return self.async_create_entry(title=data[CONF_HOST], data=data)
+
+
+class CannotConnect(exceptions.HomeAssistantError):
+    """Error to indicate we cannot connect."""
+
+
+class InvalidAuth(exceptions.HomeAssistantError):
+    """Error to indicate there is invalid auth."""

homeassistant/components/iotawatt/const.py

@@ -0,0 +1,6 @@
+"""Constants for the IoTaWatt integration."""
+from __future__ import annotations
+
+DOMAIN = "iotawatt"
+VOLT_AMPERE_REACTIVE = "VAR"
+VOLT_AMPERE_REACTIVE_HOURS = "VARh"

homeassistant/components/iotawatt/coordinator.py

@@ -0,0 +1,41 @@
+"""IoTaWatt DataUpdateCoordinator."""
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from iotawattpy.iotawatt import Iotawatt
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import httpx_client
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class IotawattUpdater(DataUpdateCoordinator):
+    """Class to manage fetching update data from the IoTaWatt Energy Device."""
+
+    def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
+        """Initialize IotaWattUpdater object."""
+        self.api = Iotawatt(
+            entry.title,
+            entry.data[CONF_HOST],
+            httpx_client.get_async_client(hass),
+            entry.data.get(CONF_USERNAME),
+            entry.data.get(CONF_PASSWORD),
+        )
+
+        super().__init__(
+            hass=hass,
+            logger=_LOGGER,
+            name=entry.title,
+            update_interval=timedelta(seconds=30),
+        )
+
+    async def _async_update_data(self):
+        """Fetch sensors from IoTaWatt device."""
+        await self.api.update()
+        return self.api.getSensors()

homeassistant/components/iotawatt/manifest.json

@@ -0,0 +1,13 @@
+{
+  "domain": "iotawatt",
+  "name": "IoTaWatt",
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/iotawatt",
+  "requirements": [
+    "iotawattpy==0.0.8"
+  ],
+  "codeowners": [
+    "@gtdiehl"
+  ],
+  "iot_class": "local_polling"
+}

homeassistant/components/iotawatt/sensor.py

@@ -0,0 +1,168 @@
+"""Support for IoTaWatt Energy monitor."""
+from __future__ import annotations
+
+from iotawattpy.sensor import Sensor
+
+from homeassistant.components.sensor import (
+    STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_TOTAL_INCREASING,
+    SensorEntity,
+    SensorEntityDescription,
+)
+from homeassistant.const import (
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_POWER_FACTOR,
+    DEVICE_CLASS_VOLTAGE,
+    ELECTRIC_CURRENT_AMPERE,
+    ELECTRIC_POTENTIAL_VOLT,
+    ENERGY_WATT_HOUR,
+    FREQUENCY_HERTZ,
+    PERCENTAGE,
+    POWER_VOLT_AMPERE,
+    POWER_WATT,
+)
+from homeassistant.core import callback
+from homeassistant.helpers import entity_registry, update_coordinator
+
+from .const import DOMAIN, VOLT_AMPERE_REACTIVE, VOLT_AMPERE_REACTIVE_HOURS
+from .coordinator import IotawattUpdater
+
+ENTITY_DESCRIPTION_KEY_MAP: dict[str, SensorEntityDescription] = {
+    "Amps": SensorEntityDescription(
+        "Amps",
+        native_unit_of_measurement=ELECTRIC_CURRENT_AMPERE,
+        state_class=STATE_CLASS_MEASUREMENT,
+        device_class=DEVICE_CLASS_CURRENT,
+    ),
+    "Hz": SensorEntityDescription(
+        "Hz",
+        native_unit_of_measurement=FREQUENCY_HERTZ,
+        state_class=STATE_CLASS_MEASUREMENT,
+    ),
+    "PF": SensorEntityDescription(
+        "PF",
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=STATE_CLASS_MEASUREMENT,
+        device_class=DEVICE_CLASS_POWER_FACTOR,
+    ),
+    "Watts": SensorEntityDescription(
+        "Watts",
+        native_unit_of_measurement=POWER_WATT,
+        state_class=STATE_CLASS_MEASUREMENT,
+        device_class=DEVICE_CLASS_POWER,
+    ),
+    "WattHours": SensorEntityDescription(
+        "WattHours",
+        native_unit_of_measurement=ENERGY_WATT_HOUR,
+        state_class=STATE_CLASS_TOTAL_INCREASING,
+        device_class=DEVICE_CLASS_ENERGY,
+    ),
+    "VA": SensorEntityDescription(
+        "VA",
+        native_unit_of_measurement=POWER_VOLT_AMPERE,
+        state_class=STATE_CLASS_MEASUREMENT,
+        device_class=DEVICE_CLASS_CURRENT,
+    ),
+    "VAR": SensorEntityDescription(
+        "VAR",
+        native_unit_of_measurement=VOLT_AMPERE_REACTIVE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    ),
+    "VARh": SensorEntityDescription(
+        "VARh",
+        native_unit_of_measurement=VOLT_AMPERE_REACTIVE_HOURS,
+        state_class=STATE_CLASS_MEASUREMENT,
+    ),
+    "Volts": SensorEntityDescription(
+        "Volts",
+        native_unit_of_measurement=ELECTRIC_POTENTIAL_VOLT,
+        state_class=STATE_CLASS_MEASUREMENT,
+        device_class=DEVICE_CLASS_VOLTAGE,
+    ),
+}
+
+
+async def async_setup_entry(hass, config_entry, async_add_entities):
+    """Add sensors for passed config_entry in HA."""
+    coordinator: IotawattUpdater = hass.data[DOMAIN][config_entry.entry_id]
+    created = set()
+
+    @callback
+    def _create_entity(key: str) -> IotaWattSensor:
+        """Create a sensor entity."""
+        created.add(key)
+        return IotaWattSensor(
+            coordinator=coordinator,
+            key=key,
+            mac_address=coordinator.data["sensors"][key].hub_mac_address,
+            name=coordinator.data["sensors"][key].getName(),
+            entity_description=ENTITY_DESCRIPTION_KEY_MAP.get(
+                coordinator.data["sensors"][key].getUnit(),
+                SensorEntityDescription("base_sensor"),
+            ),
+        )
+
+    async_add_entities(_create_entity(key) for key in coordinator.data["sensors"])
+
+    @callback
+    def new_data_received():
+        """Check for new sensors."""
+        entities = [
+            _create_entity(key)
+            for key in coordinator.data["sensors"]
+            if key not in created
+        ]
+        if entities:
+            async_add_entities(entities)
+
+    coordinator.async_add_listener(new_data_received)
+
+
+class IotaWattSensor(update_coordinator.CoordinatorEntity, SensorEntity):
+    """Defines a IoTaWatt Energy Sensor."""
+
+    _attr_force_update = True
+
+    def __init__(self, coordinator, key, mac_address, name, entity_description):
+        """Initialize the sensor."""
+        super().__init__(coordinator=coordinator)
+
+        self._key = key
+        self._attr_unique_id = self._sensor_data.getSensorID()
+        self.entity_description = entity_description
+
+    @property
+    def _sensor_data(self) -> Sensor:
+        """Return sensor data."""
+        return self.coordinator.data["sensors"][self._key]
+
+    @property
+    def name(self) -> str | None:
+        """Return name of the entity."""
+        return self._sensor_data.getName()
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        if self._key not in self.coordinator.data["sensors"]:
+            entity_registry.async_get(self.hass).async_remove(self.entity_id)
+            return
+
+        super()._handle_coordinator_update()
+
+    @property
+    def extra_state_attributes(self):
+        """Return the extra state attributes of the entity."""
+        data = self._sensor_data
+        attrs = {"type": data.getType()}
+        if attrs["type"] == "Input":
+            attrs["channel"] = data.getChannel()
+
+        return attrs
+
+    @property
+    def native_value(self):
+        """Return the state of the sensor."""
+        return self._sensor_data.getValue()

homeassistant/components/iotawatt/strings.json

@@ -0,0 +1,24 @@
+{
+  "title": "iotawatt",
+  "config": {
+    "step": {
+      "user": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]"
+        }
+      },
+      "auth": {
+        "data": {
+          "username": "[%key:common::config_flow::data::username%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "description": "The IoTawatt device requires authentication. Please enter the username and password and click the Submit button."
+      }
+    },
+    "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%]"
+    }
+  }
+}