Add Senziio core integration

CODEOWNERS

@@ -1217,6 +1217,8 @@ build.json @home-assistant/supervisor
 /tests/components/sentry/ @dcramer @frenck
 /homeassistant/components/senz/ @milanmeu
 /tests/components/senz/ @milanmeu
+/homeassistant/components/senziio/ @pmiguez @fzuccolo
+/tests/components/senziio/ @pmiguez @fzuccolo
 /homeassistant/components/serial/ @fabaff
 /homeassistant/components/seven_segments/ @fabaff
 /homeassistant/components/seventeentrack/ @shaiu

homeassistant/components/senziio/__init__.py

@@ -0,0 +1,63 @@
+"""Senziio integration."""
+
+from __future__ import annotations
+
+import logging
+
+from homeassistant.components import mqtt
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_MODEL, CONF_UNIQUE_ID, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceInfo
+
+from .const import DOMAIN, MANUFACTURER
+from .device import SenziioDevice
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up Senziio device from a config entry."""
+
+    # Make sure MQTT integration is enabled and the client is available.
+    if not await mqtt.async_wait_for_mqtt_client(hass):
+        _LOGGER.error("MQTT integration is not available")
+        return False
+
+    device_id = entry.data[CONF_UNIQUE_ID]
+    device_model = entry.data[CONF_MODEL]
+    device = SenziioDevice(device_id, device_model, hass)
+
+    registry_info = DeviceInfo(
+        identifiers={(DOMAIN, device_id)},
+        name=entry.title,
+        manufacturer=MANUFACTURER,
+        model=device_model,
+        sw_version=entry.data["fw-version"],
+        serial_number=entry.data["serial-number"],
+        connections={(dr.CONNECTION_NETWORK_MAC, entry.data["mac-address"])},
+    )
+    device_registry = dr.async_get(hass)
+    device_registry.async_get_or_create(
+        config_entry_id=entry.entry_id,
+        **registry_info,
+    )
+
+    hass.data.setdefault(DOMAIN, {})
+    hass.data[DOMAIN][entry.entry_id] = device
+
+    # forward setup to all platforms
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unload_ok

homeassistant/components/senziio/config_flow.py

@@ -0,0 +1,188 @@
+"""Config flows for Senziio integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.components import zeroconf
+from homeassistant.const import CONF_FRIENDLY_NAME, CONF_MODEL, CONF_UNIQUE_ID
+from homeassistant.core import HomeAssistant
+
+from .const import DOMAIN, MANUFACTURER
+from .device import SenziioDevice
+from .exceptions import CannotConnect, MQTTNotEnabled, RepeatedTitle
+
+_LOGGER = logging.getLogger(__name__)
+
+_input_type = vol.All(str, vol.Strip)
+
+
+class SenziioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flows for Senziio Sensor."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> config_entries.ConfigFlowResult:
+        """Handle Senziio user setup."""
+        errors: dict[str, str] = {}
+
+        device_id = ""
+        device_model = ""
+        friendly_name = self._get_friendly_name()
+
+        if user_input is not None:
+            device_id = user_input[CONF_UNIQUE_ID]
+            device_model = user_input[CONF_MODEL]
+            friendly_name = user_input[CONF_FRIENDLY_NAME]
+
+            await self.async_set_unique_id(device_id)
+            self._abort_if_unique_id_configured()
+
+            try:
+                data = await validate_input(self.hass, user_input)
+            except MQTTNotEnabled:
+                errors["base"] = "mqtt_not_enabled"
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except RepeatedTitle:
+                errors["base"] = "repeated_title"
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                return self.async_create_entry(
+                    title=friendly_name,
+                    data=data,
+                )
+
+        step_user_data_schema = vol.Schema(
+            {
+                vol.Required(CONF_UNIQUE_ID, default=device_id): _input_type,
+                vol.Required(CONF_MODEL, default=device_model): _input_type,
+                vol.Required(CONF_FRIENDLY_NAME, default=friendly_name): _input_type,
+            }
+        )
+
+        return self.async_show_form(
+            step_id="user", data_schema=step_user_data_schema, errors=errors
+        )
+
+    async def async_step_zeroconf(
+        self, discovery_info: zeroconf.ZeroconfServiceInfo
+    ) -> config_entries.ConfigFlowResult:
+        """Handle Senziio device discovered via Zeroconf."""
+        _LOGGER.info("Discovered Senziio device via Zeroconf")
+
+        device_id = discovery_info.properties["device_id"]
+
+        await self.async_set_unique_id(device_id)
+        self._abort_if_unique_id_configured()
+
+        self.context[CONF_UNIQUE_ID] = device_id
+        self.context[CONF_MODEL] = discovery_info.properties["device_model"]
+
+        return await self.async_step_zeroconf_confirm()
+
+    async def async_step_zeroconf_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> config_entries.ConfigFlowResult:
+        """Confirm the addition of a Senziio device discovered via Zeroconf."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            device_id = self.context[CONF_UNIQUE_ID]
+            friendly_name = user_input[CONF_FRIENDLY_NAME]
+            data_input = {
+                CONF_UNIQUE_ID: device_id,
+                CONF_MODEL: self.context[CONF_MODEL],
+                CONF_FRIENDLY_NAME: friendly_name,
+            }
+
+            try:
+                data = await validate_input(self.hass, data_input)
+            except MQTTNotEnabled:
+                errors["base"] = "mqtt_not_enabled"
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except RepeatedTitle:
+                errors["base"] = "repeated_title"
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.error("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                return self.async_create_entry(
+                    title=friendly_name,
+                    data=data,
+                )
+
+        data_schema = vol.Schema(
+            {
+                vol.Required(
+                    CONF_FRIENDLY_NAME,
+                    default=self._get_friendly_name(),
+                ): vol.All(str, vol.Strip),
+            }
+        )
+
+        return self.async_show_form(
+            step_id="zeroconf_confirm",
+            description_placeholders={
+                "device_id": self.context[CONF_UNIQUE_ID],
+                "device_model": self.context[CONF_MODEL],
+            },
+            data_schema=data_schema,
+            errors=errors,
+        )
+
+    def _get_friendly_name(self):
+        """Get a unique friendly name to display as device title."""
+        used_titles = {
+            entry.title for entry in self._async_current_entries(include_ignore=True)
+        }
+        prefix = MANUFACTURER
+        if model := self.context.get(CONF_MODEL):
+            prefix = f"{MANUFACTURER} {model}"
+        number = len(used_titles) + 1
+        while (title := f"{prefix} {number}") in used_titles:
+            number += 1
+        return title
+
+
+async def validate_input(
+    hass: HomeAssistant, data_input: dict[str, Any]
+) -> dict[str, Any]:
+    """Validate input data."""
+    # check friendly name is unique
+    friendly_name = _sanitize(data_input[CONF_FRIENDLY_NAME])
+    existing_titles = {
+        entry.title for entry in hass.config_entries.async_entries(DOMAIN)
+    }
+    if friendly_name in existing_titles:
+        raise RepeatedTitle
+
+    # validate device response
+    device_id = _sanitize(data_input[CONF_UNIQUE_ID])
+    device_model = _sanitize(data_input[CONF_MODEL])
+    device = SenziioDevice(device_id, device_model, hass)
+    device_info = await device.get_info()
+
+    if not device_info:
+        raise CannotConnect
+
+    return {
+        CONF_UNIQUE_ID: device_id,
+        CONF_MODEL: device_model,
+        CONF_FRIENDLY_NAME: friendly_name,
+        **device_info,
+    }
+
+
+def _sanitize(value: str) -> str:
+    """Sanitize entry value."""
+    return " ".join(value.split())

homeassistant/components/senziio/const.py

@@ -0,0 +1,4 @@
+"""Constants for the Senziio integration."""
+
+DOMAIN = "senziio"
+MANUFACTURER = "Senziio"

homeassistant/components/senziio/device.py

@@ -0,0 +1,46 @@
+"""Support for Senziio devices."""
+
+from collections.abc import Callable
+import logging
+
+from senziio import Senziio, SenziioMQTT
+
+from homeassistant.components.mqtt import async_publish, async_subscribe
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+
+from .exceptions import MQTTNotEnabled
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SenziioDevice(Senziio):
+    """Senziio device interaction."""
+
+    def __init__(self, device_id: str, device_model: str, hass: HomeAssistant) -> None:
+        """Initialize Senziio instance."""
+        super().__init__(device_id, device_model, mqtt=SenziioHAMQTT(hass))
+
+
+class SenziioHAMQTT(SenziioMQTT):
+    """Senziio MQTT interface using available integration."""
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        """Initialize MQTT interface for Senziio devices."""
+        self._hass = hass
+
+    async def publish(self, topic: str, payload: str) -> None:
+        """Publish to topic with a payload."""
+        try:
+            return await async_publish(self._hass, topic, payload)
+        except HomeAssistantError as error:
+            _LOGGER.error("Could not publish to MQTT topic")
+            raise MQTTNotEnabled from error
+
+    async def subscribe(self, topic: str, callback: Callable) -> Callable:
+        """Subscribe to topic with a callback."""
+        try:
+            return await async_subscribe(self._hass, topic, callback)
+        except HomeAssistantError as error:
+            _LOGGER.error("Could not subscribe to MQTT topic")
+            raise MQTTNotEnabled from error

homeassistant/components/senziio/exceptions.py

@@ -0,0 +1,15 @@
+"""Errors for Senziio integration."""
+
+from homeassistant.exceptions import HomeAssistantError
+
+
+class CannotConnect(HomeAssistantError):
+    """Error to indicate we cannot connect to the device."""
+
+
+class RepeatedTitle(HomeAssistantError):
+    """Error to indicate that chosen device name is not unique."""
+
+
+class MQTTNotEnabled(HomeAssistantError):
+    """Error to indicate that required MQTT integration is not enabled."""

homeassistant/components/senziio/icons.json

@@ -0,0 +1,24 @@
+{
+  "entity": {
+    "sensor": {
+      "person-counter": {
+        "default": "mdi:human"
+      },
+      "atmospheric-pressure": {
+        "default": "mdi:gauge"
+      },
+      "co2": {
+        "default": "mdi:molecule-co2"
+      },
+      "illuminance": {
+        "default": "mdi:brightness-5"
+      },
+      "humidity": {
+        "default": "mdi:water-percent"
+      },
+      "temperature": {
+        "default": "mdi:thermometer"
+      }
+    }
+  }
+}

homeassistant/components/senziio/manifest.json

@@ -0,0 +1,17 @@
+{
+  "domain": "senziio",
+  "name": "Senziio",
+  "codeowners": ["@pmiguez", "@fzuccolo"],
+  "config_flow": true,
+  "dependencies": ["mqtt"],
+  "documentation": "https://www.home-assistant.io/integrations/senziio",
+  "homekit": {},
+  "iot_class": "local_push",
+  "requirements": ["senziio==0.0.1"],
+  "zeroconf": [
+    {
+      "type": "_http._tcp.local.",
+      "name": "senziio*"
+    }
+  ]
+}