"""Utility meter from sensors providing raw data.""" import logging from datetime import date, timedelta from decimal import Decimal, DecimalException import homeassistant.util.dt as dt_util from homeassistant.const import ( CONF_NAME, ATTR_UNIT_OF_MEASUREMENT, EVENT_HOMEASSISTANT_START, STATE_UNKNOWN, STATE_UNAVAILABLE) from homeassistant.core import callback from homeassistant.helpers.event import ( async_track_state_change, async_track_time_change) from homeassistant.helpers.dispatcher import ( async_dispatcher_connect) from homeassistant.helpers.restore_state import RestoreEntity from .const import ( DATA_UTILITY, SIGNAL_RESET_METER, HOURLY, DAILY, WEEKLY, MONTHLY, YEARLY, CONF_SOURCE_SENSOR, CONF_METER_TYPE, CONF_METER_OFFSET, CONF_METER_NET_CONSUMPTION, CONF_TARIFF, CONF_TARIFF_ENTITY, CONF_METER) _LOGGER = logging.getLogger(__name__) ATTR_SOURCE_ID = 'source' ATTR_STATUS = 'status' ATTR_PERIOD = 'meter_period' ATTR_LAST_PERIOD = 'last_period' ATTR_LAST_RESET = 'last_reset' ATTR_TARIFF = 'tariff' ICON = 'mdi:counter' PRECISION = 3 PAUSED = 'paused' COLLECTING = 'collecting' async def async_setup_platform( hass, config, async_add_entities, discovery_info=None): """Set up the utility meter sensor.""" if discovery_info is None: _LOGGER.error("This platform is only available through discovery") return meters = [] for conf in discovery_info: meter = conf[CONF_METER] conf_meter_source = hass.data[DATA_UTILITY][meter][CONF_SOURCE_SENSOR] conf_meter_type = hass.data[DATA_UTILITY][meter].get(CONF_METER_TYPE) conf_meter_offset = hass.data[DATA_UTILITY][meter][CONF_METER_OFFSET] conf_meter_net_consumption =\ hass.data[DATA_UTILITY][meter][CONF_METER_NET_CONSUMPTION] conf_meter_tariff_entity = hass.data[DATA_UTILITY][meter].get( CONF_TARIFF_ENTITY) meters.append(UtilityMeterSensor( conf_meter_source, conf.get(CONF_NAME), conf_meter_type, conf_meter_offset, conf_meter_net_consumption, conf.get(CONF_TARIFF), conf_meter_tariff_entity)) async_add_entities(meters) class UtilityMeterSensor(RestoreEntity): """Representation of an utility meter sensor.""" def __init__(self, source_entity, name, meter_type, meter_offset, net_consumption, tariff=None, tariff_entity=None): """Initialize the Utility Meter sensor.""" self._sensor_source_id = source_entity self._state = 0 self._last_period = 0 self._last_reset = dt_util.now() self._collecting = None if name: self._name = name else: self._name = '{} meter'.format(source_entity) self._unit_of_measurement = None self._period = meter_type self._period_offset = meter_offset self._sensor_net_consumption = net_consumption self._tariff = tariff self._tariff_entity = tariff_entity @callback def async_reading(self, entity, old_state, new_state): """Handle the sensor state changes.""" if old_state is None or new_state is None or\ old_state.state in [STATE_UNKNOWN, STATE_UNAVAILABLE] or\ new_state.state in [STATE_UNKNOWN, STATE_UNAVAILABLE]: return if self._unit_of_measurement is None and\ new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) is not None: self._unit_of_measurement = new_state.attributes.get( ATTR_UNIT_OF_MEASUREMENT) try: diff = Decimal(new_state.state) - Decimal(old_state.state) if (not self._sensor_net_consumption) and diff < 0: # Source sensor just rolled over for unknow reasons, return self._state += diff except ValueError as err: _LOGGER.warning("While processing state changes: %s", err) except DecimalException as err: _LOGGER.warning("Invalid state (%s > %s): %s", old_state.state, new_state.state, err) self.async_schedule_update_ha_state() @callback def async_tariff_change(self, entity, old_state, new_state): """Handle tariff changes.""" if self._tariff == new_state.state: self._collecting = async_track_state_change( self.hass, self._sensor_source_id, self.async_reading) else: if self._collecting: self._collecting() self._collecting = None _LOGGER.debug("%s - %s - source <%s>", self._name, COLLECTING if self._collecting is not None else PAUSED, self._sensor_source_id) self.async_schedule_update_ha_state() async def _async_reset_meter(self, event): """Determine cycle - Helper function for larger than daily cycles.""" now = dt_util.now().date() if self._period == WEEKLY and\ now != now - timedelta(days=now.weekday())\ + self._period_offset: return if self._period == MONTHLY and\ now != date(now.year, now.month, 1) + self._period_offset: return if self._period == YEARLY and\ now != date(now.year, 1, 1) + self._period_offset: return await self.async_reset_meter(self._tariff_entity) async def async_reset_meter(self, entity_id): """Reset meter.""" if self._tariff_entity != entity_id: return _LOGGER.debug("Reset utility meter <%s>", self.entity_id) self._last_reset = dt_util.now() self._last_period = str(self._state) self._state = 0 await self.async_update_ha_state() async def async_added_to_hass(self): """Handle entity which will be added.""" await super().async_added_to_hass() if self._period == HOURLY: async_track_time_change( self.hass, self._async_reset_meter, minute=self._period_offset.seconds // 60, second=self._period_offset.seconds % 60) elif self._period in [DAILY, WEEKLY, MONTHLY, YEARLY]: async_track_time_change( self.hass, self._async_reset_meter, hour=self._period_offset.seconds // 3600, minute=self._period_offset.seconds % 3600 // 60, second=self._period_offset.seconds % 3600 % 60) async_dispatcher_connect( self.hass, SIGNAL_RESET_METER, self.async_reset_meter) state = await self.async_get_last_state() if state: self._state = Decimal(state.state) self._unit_of_measurement = state.attributes.get( ATTR_UNIT_OF_MEASUREMENT) self._last_period = state.attributes.get(ATTR_LAST_PERIOD) self._last_reset = state.attributes.get(ATTR_LAST_RESET) await self.async_update_ha_state() if state.attributes.get(ATTR_STATUS) == PAUSED: # Fake cancellation function to init the meter paused self._collecting = lambda: None @callback def async_source_tracking(event): """Wait for source to be ready, then start meter.""" if self._tariff_entity is not None: _LOGGER.debug("Track %s", self._tariff_entity) async_track_state_change( self.hass, self._tariff_entity, self.async_tariff_change) tariff_entity_state = self.hass.states.get(self._tariff_entity) if self._tariff != tariff_entity_state.state: return _LOGGER.debug("tracking source: %s", self._sensor_source_id) self._collecting = async_track_state_change( self.hass, self._sensor_source_id, self.async_reading) self.hass.bus.async_listen_once( EVENT_HOMEASSISTANT_START, async_source_tracking) @property def name(self): """Return the name of the sensor.""" return self._name @property def state(self): """Return the state of the sensor.""" return self._state @property def unit_of_measurement(self): """Return the unit the value is expressed in.""" return self._unit_of_measurement @property def should_poll(self): """No polling needed.""" return False @property def device_state_attributes(self): """Return the state attributes of the sensor.""" state_attr = { ATTR_SOURCE_ID: self._sensor_source_id, ATTR_STATUS: PAUSED if self._collecting is None else COLLECTING, ATTR_LAST_PERIOD: self._last_period, ATTR_LAST_RESET: self._last_reset, } if self._period is not None: state_attr[ATTR_PERIOD] = self._period if self._tariff is not None: state_attr[ATTR_TARIFF] = self._tariff return state_attr @property def icon(self): """Return the icon to use in the frontend, if any.""" return ICON