44fefb3216
Most of the the template platforms would check for extract_entities failing to extract entities and avoid setting up a state change listner for MATCH_ALL after extract_entities had warned that it could not extract the entities and updates would need to be done manually. This protection has been extended to all template platforms. Alter the behavior of extract_entities to return the successfully extracted entities if one or more templates fail extraction instead of returning MATCH_ALL
285 lines
9.3 KiB
Python
285 lines
9.3 KiB
Python
"""Allows the creation of a sensor that breaks out state_attributes."""
|
|
import logging
|
|
from typing import Optional
|
|
|
|
import voluptuous as vol
|
|
|
|
from homeassistant.components.sensor import (
|
|
DEVICE_CLASSES_SCHEMA,
|
|
ENTITY_ID_FORMAT,
|
|
PLATFORM_SCHEMA,
|
|
)
|
|
from homeassistant.const import (
|
|
ATTR_ENTITY_ID,
|
|
ATTR_FRIENDLY_NAME,
|
|
ATTR_UNIT_OF_MEASUREMENT,
|
|
CONF_DEVICE_CLASS,
|
|
CONF_ENTITY_PICTURE_TEMPLATE,
|
|
CONF_FRIENDLY_NAME_TEMPLATE,
|
|
CONF_ICON_TEMPLATE,
|
|
CONF_SENSORS,
|
|
CONF_VALUE_TEMPLATE,
|
|
EVENT_HOMEASSISTANT_START,
|
|
MATCH_ALL,
|
|
)
|
|
from homeassistant.core import callback
|
|
from homeassistant.exceptions import TemplateError
|
|
import homeassistant.helpers.config_validation as cv
|
|
from homeassistant.helpers.entity import Entity, async_generate_entity_id
|
|
from homeassistant.helpers.event import async_track_state_change_event
|
|
|
|
from . import extract_entities, initialise_templates
|
|
from .const import CONF_AVAILABILITY_TEMPLATE
|
|
|
|
CONF_ATTRIBUTE_TEMPLATES = "attribute_templates"
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
SENSOR_SCHEMA = vol.Schema(
|
|
{
|
|
vol.Required(CONF_VALUE_TEMPLATE): cv.template,
|
|
vol.Optional(CONF_ICON_TEMPLATE): cv.template,
|
|
vol.Optional(CONF_ENTITY_PICTURE_TEMPLATE): cv.template,
|
|
vol.Optional(CONF_FRIENDLY_NAME_TEMPLATE): cv.template,
|
|
vol.Optional(CONF_AVAILABILITY_TEMPLATE): cv.template,
|
|
vol.Optional(CONF_ATTRIBUTE_TEMPLATES, default={}): vol.Schema(
|
|
{cv.string: cv.template}
|
|
),
|
|
vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
|
|
vol.Optional(ATTR_UNIT_OF_MEASUREMENT): cv.string,
|
|
vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
|
|
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
|
|
}
|
|
)
|
|
|
|
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
|
|
{vol.Required(CONF_SENSORS): cv.schema_with_slug_keys(SENSOR_SCHEMA)}
|
|
)
|
|
|
|
|
|
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
|
|
"""Set up the template sensors."""
|
|
sensors = []
|
|
|
|
for device, device_config in config[CONF_SENSORS].items():
|
|
state_template = device_config[CONF_VALUE_TEMPLATE]
|
|
icon_template = device_config.get(CONF_ICON_TEMPLATE)
|
|
entity_picture_template = device_config.get(CONF_ENTITY_PICTURE_TEMPLATE)
|
|
availability_template = device_config.get(CONF_AVAILABILITY_TEMPLATE)
|
|
friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
|
|
friendly_name_template = device_config.get(CONF_FRIENDLY_NAME_TEMPLATE)
|
|
unit_of_measurement = device_config.get(ATTR_UNIT_OF_MEASUREMENT)
|
|
device_class = device_config.get(CONF_DEVICE_CLASS)
|
|
attribute_templates = device_config[CONF_ATTRIBUTE_TEMPLATES]
|
|
|
|
templates = {
|
|
CONF_VALUE_TEMPLATE: state_template,
|
|
CONF_ICON_TEMPLATE: icon_template,
|
|
CONF_ENTITY_PICTURE_TEMPLATE: entity_picture_template,
|
|
CONF_FRIENDLY_NAME_TEMPLATE: friendly_name_template,
|
|
CONF_AVAILABILITY_TEMPLATE: availability_template,
|
|
}
|
|
|
|
initialise_templates(hass, templates, attribute_templates)
|
|
entity_ids = extract_entities(
|
|
device,
|
|
"sensor",
|
|
device_config.get(ATTR_ENTITY_ID),
|
|
templates,
|
|
attribute_templates,
|
|
)
|
|
|
|
sensors.append(
|
|
SensorTemplate(
|
|
hass,
|
|
device,
|
|
friendly_name,
|
|
friendly_name_template,
|
|
unit_of_measurement,
|
|
state_template,
|
|
icon_template,
|
|
entity_picture_template,
|
|
availability_template,
|
|
entity_ids,
|
|
device_class,
|
|
attribute_templates,
|
|
)
|
|
)
|
|
|
|
async_add_entities(sensors)
|
|
|
|
return True
|
|
|
|
|
|
class SensorTemplate(Entity):
|
|
"""Representation of a Template Sensor."""
|
|
|
|
def __init__(
|
|
self,
|
|
hass,
|
|
device_id,
|
|
friendly_name,
|
|
friendly_name_template,
|
|
unit_of_measurement,
|
|
state_template,
|
|
icon_template,
|
|
entity_picture_template,
|
|
availability_template,
|
|
entity_ids,
|
|
device_class,
|
|
attribute_templates,
|
|
):
|
|
"""Initialize the sensor."""
|
|
self.hass = hass
|
|
self.entity_id = async_generate_entity_id(
|
|
ENTITY_ID_FORMAT, device_id, hass=hass
|
|
)
|
|
self._name = friendly_name
|
|
self._friendly_name_template = friendly_name_template
|
|
self._unit_of_measurement = unit_of_measurement
|
|
self._template = state_template
|
|
self._state = None
|
|
self._icon_template = icon_template
|
|
self._entity_picture_template = entity_picture_template
|
|
self._availability_template = availability_template
|
|
self._icon = None
|
|
self._entity_picture = None
|
|
self._entities = entity_ids
|
|
self._device_class = device_class
|
|
self._available = True
|
|
self._attribute_templates = attribute_templates
|
|
self._attributes = {}
|
|
|
|
async def async_added_to_hass(self):
|
|
"""Register callbacks."""
|
|
|
|
@callback
|
|
def template_sensor_state_listener(event):
|
|
"""Handle device state changes."""
|
|
self.async_schedule_update_ha_state(True)
|
|
|
|
@callback
|
|
def template_sensor_startup(event):
|
|
"""Update template on startup."""
|
|
if self._entities != MATCH_ALL:
|
|
# Track state change only for valid templates
|
|
async_track_state_change_event(
|
|
self.hass, self._entities, template_sensor_state_listener
|
|
)
|
|
|
|
self.async_schedule_update_ha_state(True)
|
|
|
|
self.hass.bus.async_listen_once(
|
|
EVENT_HOMEASSISTANT_START, template_sensor_startup
|
|
)
|
|
|
|
@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 icon(self):
|
|
"""Return the icon to use in the frontend, if any."""
|
|
return self._icon
|
|
|
|
@property
|
|
def device_class(self) -> Optional[str]:
|
|
"""Return the device class of the sensor."""
|
|
return self._device_class
|
|
|
|
@property
|
|
def entity_picture(self):
|
|
"""Return the entity_picture to use in the frontend, if any."""
|
|
return self._entity_picture
|
|
|
|
@property
|
|
def unit_of_measurement(self):
|
|
"""Return the unit_of_measurement of the device."""
|
|
return self._unit_of_measurement
|
|
|
|
@property
|
|
def available(self) -> bool:
|
|
"""Return if the device is available."""
|
|
return self._available
|
|
|
|
@property
|
|
def device_state_attributes(self):
|
|
"""Return the state attributes."""
|
|
return self._attributes
|
|
|
|
@property
|
|
def should_poll(self):
|
|
"""No polling needed."""
|
|
return False
|
|
|
|
async def async_update(self):
|
|
"""Update the state from the template."""
|
|
try:
|
|
self._state = self._template.async_render()
|
|
self._available = True
|
|
except TemplateError as ex:
|
|
self._available = False
|
|
if ex.args and ex.args[0].startswith(
|
|
"UndefinedError: 'None' has no attribute"
|
|
):
|
|
# Common during HA startup - so just a warning
|
|
_LOGGER.warning(
|
|
"Could not render template %s, the state is unknown", self._name
|
|
)
|
|
else:
|
|
self._state = None
|
|
_LOGGER.error("Could not render template %s: %s", self._name, ex)
|
|
|
|
attrs = {}
|
|
for key, value in self._attribute_templates.items():
|
|
try:
|
|
attrs[key] = value.async_render()
|
|
except TemplateError as err:
|
|
_LOGGER.error("Error rendering attribute %s: %s", key, err)
|
|
|
|
self._attributes = attrs
|
|
|
|
templates = {
|
|
"_icon": self._icon_template,
|
|
"_entity_picture": self._entity_picture_template,
|
|
"_name": self._friendly_name_template,
|
|
"_available": self._availability_template,
|
|
}
|
|
|
|
for property_name, template in templates.items():
|
|
if template is None:
|
|
continue
|
|
|
|
try:
|
|
value = template.async_render()
|
|
if property_name == "_available":
|
|
value = value.lower() == "true"
|
|
setattr(self, property_name, value)
|
|
except TemplateError as ex:
|
|
friendly_property_name = property_name[1:].replace("_", " ")
|
|
if ex.args and ex.args[0].startswith(
|
|
"UndefinedError: 'None' has no attribute"
|
|
):
|
|
# Common during HA startup - so just a warning
|
|
_LOGGER.warning(
|
|
"Could not render %s template %s, the state is unknown",
|
|
friendly_property_name,
|
|
self._name,
|
|
)
|
|
continue
|
|
|
|
try:
|
|
setattr(self, property_name, getattr(super(), property_name))
|
|
except AttributeError:
|
|
_LOGGER.error(
|
|
"Could not render %s template %s: %s",
|
|
friendly_property_name,
|
|
self._name,
|
|
ex,
|
|
)
|