Add Libre Hardware Monitor integration (home-assistant#140449)

Author: Sab44

.strict-typing

@@ -307,6 +307,7 @@ homeassistant.components.ld2410_ble.*
 homeassistant.components.led_ble.*
 homeassistant.components.lektrico.*
 homeassistant.components.letpot.*
+homeassistant.components.libre_hardware_monitor.*
 homeassistant.components.lidarr.*
 homeassistant.components.lifx.*
 homeassistant.components.light.*

CODEOWNERS

@@ -0,0 +1,34 @@
+"""The LibreHardwareMonitor integration."""
+
+from __future__ import annotations
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import (
+    LibreHardwareMonitorConfigEntry,
+    LibreHardwareMonitorCoordinator,
+)
+
+PLATFORMS = [Platform.SENSOR]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, config_entry: LibreHardwareMonitorConfigEntry
+) -> bool:
+    """Set up LibreHardwareMonitor from a config entry."""
+
+    lhm_coordinator = LibreHardwareMonitorCoordinator(hass, config_entry)
+    await lhm_coordinator.async_config_entry_first_refresh()
+
+    config_entry.runtime_data = lhm_coordinator
+    await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, config_entry: LibreHardwareMonitorConfigEntry
+) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)

homeassistant/components/libre_hardware_monitor/__init__.py

@@ -0,0 +1,63 @@
+"""Config flow for LibreHardwareMonitor."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from librehardwaremonitor_api import (
+    LibreHardwareMonitorClient,
+    LibreHardwareMonitorConnectionError,
+    LibreHardwareMonitorNoDevicesError,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_HOST, CONF_PORT
+
+from .const import DEFAULT_HOST, DEFAULT_PORT, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_HOST, default=DEFAULT_HOST): str,
+        vol.Required(CONF_PORT, default=DEFAULT_PORT): int,
+    }
+)
+
+
+class LibreHardwareMonitorConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for LibreHardwareMonitor."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors = {}
+
+        if user_input is not None:
+            self._async_abort_entries_match(user_input)
+
+            api = LibreHardwareMonitorClient(
+                user_input[CONF_HOST], user_input[CONF_PORT]
+            )
+
+            try:
+                _ = (await api.get_data()).main_device_ids_and_names.values()
+            except LibreHardwareMonitorConnectionError as exception:
+                _LOGGER.error(exception)
+                errors["base"] = "cannot_connect"
+            except LibreHardwareMonitorNoDevicesError:
+                errors["base"] = "no_devices"
+            else:
+                return self.async_create_entry(
+                    title=f"{user_input[CONF_HOST]}:{user_input[CONF_PORT]}",
+                    data=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="user", data_schema=CONFIG_SCHEMA, errors=errors
+        )

homeassistant/components/libre_hardware_monitor/config_flow.py

@@ -0,0 +1,6 @@
+"""Constants for the LibreHardwareMonitor integration."""
+
+DOMAIN = "libre_hardware_monitor"
+DEFAULT_HOST = "localhost"
+DEFAULT_PORT = 8085
+DEFAULT_SCAN_INTERVAL = 10

homeassistant/components/libre_hardware_monitor/const.py

@@ -0,0 +1,130 @@
+"""Coordinator for LibreHardwareMonitor integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+from types import MappingProxyType
+
+from librehardwaremonitor_api import (
+    LibreHardwareMonitorClient,
+    LibreHardwareMonitorConnectionError,
+    LibreHardwareMonitorNoDevicesError,
+)
+from librehardwaremonitor_api.model import (
+    DeviceId,
+    DeviceName,
+    LibreHardwareMonitorData,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST, CONF_PORT
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceEntry
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+type LibreHardwareMonitorConfigEntry = ConfigEntry[LibreHardwareMonitorCoordinator]
+
+
+class LibreHardwareMonitorCoordinator(DataUpdateCoordinator[LibreHardwareMonitorData]):
+    """Class to manage fetching LibreHardwareMonitor data."""
+
+    config_entry: LibreHardwareMonitorConfigEntry
+
+    def __init__(
+        self, hass: HomeAssistant, config_entry: LibreHardwareMonitorConfigEntry
+    ) -> None:
+        """Initialize."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            config_entry=config_entry,
+            update_interval=timedelta(seconds=DEFAULT_SCAN_INTERVAL),
+        )
+
+        host = config_entry.data[CONF_HOST]
+        port = config_entry.data[CONF_PORT]
+        self._api = LibreHardwareMonitorClient(host, port)
+        device_entries: list[DeviceEntry] = dr.async_entries_for_config_entry(
+            registry=dr.async_get(self.hass), config_entry_id=config_entry.entry_id
+        )
+        self._previous_devices: MappingProxyType[DeviceId, DeviceName] = (
+            MappingProxyType(
+                {
+                    DeviceId(next(iter(device.identifiers))[1]): DeviceName(device.name)
+                    for device in device_entries
+                    if device.identifiers and device.name
+                }
+            )
+        )
+
+    async def _async_update_data(self) -> LibreHardwareMonitorData:
+        try:
+            lhm_data = await self._api.get_data()
+        except LibreHardwareMonitorConnectionError as err:
+            raise UpdateFailed(
+                "LibreHardwareMonitor connection failed, will retry"
+            ) from err
+        except LibreHardwareMonitorNoDevicesError as err:
+            raise UpdateFailed("No sensor data available, will retry") from err
+
+        await self._async_handle_changes_in_devices(lhm_data.main_device_ids_and_names)
+
+        return lhm_data
+
+    async def _async_refresh(
+        self,
+        log_failures: bool = True,
+        raise_on_auth_failed: bool = False,
+        scheduled: bool = False,
+        raise_on_entry_error: bool = False,
+    ) -> None:
+        # we don't expect the computer to be online 24/7 so we don't want to log a connection loss as an error
+        await super()._async_refresh(
+            False, raise_on_auth_failed, scheduled, raise_on_entry_error
+        )
+
+    async def _async_handle_changes_in_devices(
+        self, detected_devices: MappingProxyType[DeviceId, DeviceName]
+    ) -> None:
+        """Handle device changes by deleting devices from / adding devices to Home Assistant."""
+        previous_device_ids = set(self._previous_devices.keys())
+        detected_device_ids = set(detected_devices.keys())
+
+        if previous_device_ids == detected_device_ids:
+            return
+
+        if self.data is None:
+            # initial update during integration startup
+            self._previous_devices = detected_devices  # type: ignore[unreachable]
+            return
+
+        if orphaned_devices := previous_device_ids - detected_device_ids:
+            _LOGGER.warning(
+                "Device(s) no longer available, will be removed: %s",
+                [self._previous_devices[device_id] for device_id in orphaned_devices],
+            )
+            device_registry = dr.async_get(self.hass)
+            for device_id in orphaned_devices:
+                if device := device_registry.async_get_device(
+                    identifiers={(DOMAIN, device_id)}
+                ):
+                    device_registry.async_update_device(
+                        device_id=device.id,
+                        remove_config_entry_id=self.config_entry.entry_id,
+                    )
+
+        if new_devices := detected_device_ids - previous_device_ids:
+            _LOGGER.warning(
+                "New Device(s) detected, reload integration to add them to Home Assistant: %s",
+                [detected_devices[DeviceId(device_id)] for device_id in new_devices],
+            )
+
+        self._previous_devices = detected_devices

homeassistant/components/libre_hardware_monitor/coordinator.py

@@ -0,0 +1,10 @@
+{
+  "domain": "libre_hardware_monitor",
+  "name": "Libre Hardware Monitor",
+  "codeowners": ["@Sab44"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/libre_hardware_monitor",
+  "iot_class": "local_polling",
+  "quality_scale": "silver",
+  "requirements": ["librehardwaremonitor-api==1.3.1"]
+}

homeassistant/components/libre_hardware_monitor/manifest.json

@@ -0,0 +1,81 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      No custom actions are defined.
+  appropriate-polling: done
+  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:
+    status: exempt
+    comment: |
+      No explicit event subscriptions.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup:
+    status: exempt
+    comment: |
+      Device is expected to be offline most of the time, but needs to connect quickly once available.
+  unique-config-entry: done
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: |
+      No custom actions are defined.
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable:
+    status: exempt
+    comment: |
+      Device is expected to be temporarily unavailable.
+  parallel-updates: done
+  reauthentication-flow:
+    status: exempt
+    comment: |
+      This integration does not require authentication.
+  test-coverage: done
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: done
+  docs-use-cases: todo
+  dynamic-devices: done
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: |
+      This integration doesn't have any cases where raising an issue is needed.
+  stale-devices: done
+  # Platinum
+  async-dependency: done
+  inject-websession: todo
+  strict-typing: done