Migrate WLED to use DataUpdateCoordinator (#32565)

* Migrate WLED to use DataUpdateCoordinator

* Remove stale debug statement

* Process review suggestions

* Improve tests

* Improve tests
This commit is contained in:
Franck Nijhof authored and GitHub committed 2020-03-13 13:19:05 +01:00
1 parent 26d7b2164e
commit 992daa4a44
8 files changed
+478 -560

No files matched your search

+63 -56
View File
@@ -1,7 +1,7 @@
"""Support for WLED sensors."""
from datetime import timedelta
import logging
from typing import Callable, List, Optional, Union
from typing import Any, Callable, Dict, List, Optional, Union
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import DATA_BYTES, DEVICE_CLASS_TIMESTAMP
@@ -9,8 +9,8 @@ from homeassistant.helpers.entity import Entity
from homeassistant.helpers.typing import HomeAssistantType
from homeassistant.util.dt import utcnow
from . import WLED, WLEDDeviceEntity
from .const import ATTR_LED_COUNT, ATTR_MAX_POWER, CURRENT_MA, DATA_WLED_CLIENT, DOMAIN
from . import WLEDDataUpdateCoordinator, WLEDDeviceEntity
from .const import ATTR_LED_COUNT, ATTR_MAX_POWER, CURRENT_MA, DOMAIN
_LOGGER = logging.getLogger(__name__)
@@ -21,12 +21,12 @@ async def async_setup_entry(
async_add_entities: Callable[[List[Entity], bool], None],
) -> None:
"""Set up WLED sensor based on a config entry."""
wled: WLED = hass.data[DOMAIN][entry.entry_id][DATA_WLED_CLIENT]
coordinator: WLEDDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
sensors = [
WLEDEstimatedCurrentSensor(entry.entry_id, wled),
WLEDUptimeSensor(entry.entry_id, wled),
WLEDFreeHeapSensor(entry.entry_id, wled),
WLEDEstimatedCurrentSensor(entry.entry_id, coordinator),
WLEDUptimeSensor(entry.entry_id, coordinator),
WLEDFreeHeapSensor(entry.entry_id, coordinator),
]
async_add_entities(sensors, True)
@@ -37,30 +37,31 @@ class WLEDSensor(WLEDDeviceEntity):
def __init__(
self,
entry_id: str,
wled: WLED,
name: str,
icon: str,
unit_of_measurement: str,
key: str,
*,
coordinator: WLEDDataUpdateCoordinator,
enabled_default: bool = True,
entry_id: str,
icon: str,
key: str,
name: str,
unit_of_measurement: Optional[str] = None,
) -> None:
"""Initialize WLED sensor."""
self._state = None
self._unit_of_measurement = unit_of_measurement
self._key = key
super().__init__(entry_id, wled, name, icon, enabled_default)
super().__init__(
entry_id=entry_id,
coordinator=coordinator,
name=name,
icon=icon,
enabled_default=enabled_default,
)
@property
def unique_id(self) -> str:
"""Return the unique ID for this sensor."""
return f"{self.wled.device.info.mac_address}_{self._key}"
@property
def state(self) -> Union[None, str, int, float]:
"""Return the state of the sensor."""
return self._state
return f"{self.coordinator.data.info.mac_address}_{self._key}"
@property
def unit_of_measurement(self) -> str:
@@ -71,67 +72,73 @@ class WLEDSensor(WLEDDeviceEntity):
class WLEDEstimatedCurrentSensor(WLEDSensor):
"""Defines a WLED estimated current sensor."""
def __init__(self, entry_id: str, wled: WLED) -> None:
def __init__(self, entry_id: str, coordinator: WLEDDataUpdateCoordinator) -> None:
"""Initialize WLED estimated current sensor."""
super().__init__(
entry_id,
wled,
f"{wled.device.info.name} Estimated Current",
"mdi:power",
CURRENT_MA,
"estimated_current",
coordinator=coordinator,
entry_id=entry_id,
icon="mdi:power",
key="estimated_current",
name=f"{coordinator.data.info.name} Estimated Current",
unit_of_measurement=CURRENT_MA,
)
async def _wled_update(self) -> None:
"""Update WLED entity."""
self._state = self.wled.device.info.leds.power
self._attributes = {
ATTR_LED_COUNT: self.wled.device.info.leds.count,
ATTR_MAX_POWER: self.wled.device.info.leds.max_power,
@property
def device_state_attributes(self) -> Optional[Dict[str, Any]]:
"""Return the state attributes of the entity."""
return {
ATTR_LED_COUNT: self.coordinator.data.info.leds.count,
ATTR_MAX_POWER: self.coordinator.data.info.leds.max_power,
}
@property
def state(self) -> Union[None, str, int, float]:
"""Return the state of the sensor."""
return self.coordinator.data.info.leds.power
class WLEDUptimeSensor(WLEDSensor):
"""Defines a WLED uptime sensor."""
def __init__(self, entry_id: str, wled: WLED) -> None:
def __init__(self, entry_id: str, coordinator: WLEDDataUpdateCoordinator) -> None:
"""Initialize WLED uptime sensor."""
super().__init__(
entry_id,
wled,
f"{wled.device.info.name} Uptime",
"mdi:clock-outline",
None,
"uptime",
coordinator=coordinator,
enabled_default=False,
entry_id=entry_id,
icon="mdi:clock-outline",
key="uptime",
name=f"{coordinator.data.info.name} Uptime",
)
@property
def state(self) -> Union[None, str, int, float]:
"""Return the state of the sensor."""
uptime = utcnow() - timedelta(seconds=self.coordinator.data.info.uptime)
return uptime.replace(microsecond=0).isoformat()
@property
def device_class(self) -> Optional[str]:
"""Return the class of this sensor."""
return DEVICE_CLASS_TIMESTAMP
async def _wled_update(self) -> None:
"""Update WLED uptime sensor."""
uptime = utcnow() - timedelta(seconds=self.wled.device.info.uptime)
self._state = uptime.replace(microsecond=0).isoformat()
class WLEDFreeHeapSensor(WLEDSensor):
"""Defines a WLED free heap sensor."""
def __init__(self, entry_id: str, wled: WLED) -> None:
def __init__(self, entry_id: str, coordinator: WLEDDataUpdateCoordinator) -> None:
"""Initialize WLED free heap sensor."""
super().__init__(
entry_id,
wled,
f"{wled.device.info.name} Free Memory",
"mdi:memory",
DATA_BYTES,
"free_heap",
coordinator=coordinator,
enabled_default=False,
entry_id=entry_id,
icon="mdi:memory",
key="free_heap",
name=f"{coordinator.data.info.name} Free Memory",
unit_of_measurement=DATA_BYTES,
)
async def _wled_update(self) -> None:
"""Update WLED uptime sensor."""
self._state = self.wled.device.info.free_heap
@property
def state(self) -> Union[None, str, int, float]:
"""Return the state of the sensor."""
return self.coordinator.data.info.free_heap