From 65126cec3e8b075d48b2df124117ae26abeaf2b2 Mon Sep 17 00:00:00 2001 From: Paulus Schoutsen Date: Mon, 12 Apr 2021 17:15:50 -0700 Subject: [PATCH] Allow top level non-trigger template entities (#48976) --- homeassistant/components/template/__init__.py | 54 ++++-- homeassistant/components/template/config.py | 117 +++--------- homeassistant/components/template/const.py | 1 + homeassistant/components/template/sensor.py | 169 +++++++++++++----- tests/components/template/test_init.py | 25 ++- tests/components/template/test_sensor.py | 2 +- 6 files changed, 211 insertions(+), 157 deletions(-) diff --git a/homeassistant/components/template/__init__.py b/homeassistant/components/template/__init__.py index 3b10e708e51..dfacac17a9b 100644 --- a/homeassistant/components/template/__init__.py +++ b/homeassistant/components/template/__init__.py @@ -6,7 +6,6 @@ import logging from typing import Callable from homeassistant import config as conf_util -from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN from homeassistant.const import EVENT_HOMEASSISTANT_START, SERVICE_RELOAD from homeassistant.core import CoreState, Event, callback from homeassistant.exceptions import HomeAssistantError @@ -57,23 +56,41 @@ async def async_setup(hass, config): return True -async def _process_config(hass, config): +async def _process_config(hass, hass_config): """Process config.""" - coordinators: list[TriggerUpdateCoordinator] | None = hass.data.get(DOMAIN) + coordinators: list[TriggerUpdateCoordinator] | None = hass.data.pop(DOMAIN, None) # Remove old ones if coordinators: for coordinator in coordinators: coordinator.async_remove() - async def init_coordinator(hass, conf): - coordinator = TriggerUpdateCoordinator(hass, conf) - await coordinator.async_setup(config) + async def init_coordinator(hass, conf_section): + coordinator = TriggerUpdateCoordinator(hass, conf_section) + await coordinator.async_setup(hass_config) return coordinator - hass.data[DOMAIN] = await asyncio.gather( - *[init_coordinator(hass, conf) for conf in config[DOMAIN]] - ) + coordinator_tasks = [] + + for conf_section in hass_config[DOMAIN]: + if CONF_TRIGGER in conf_section: + coordinator_tasks.append(init_coordinator(hass, conf_section)) + continue + + for platform_domain in PLATFORMS: + if platform_domain in conf_section: + hass.async_create_task( + discovery.async_load_platform( + hass, + platform_domain, + DOMAIN, + {"entities": conf_section[platform_domain]}, + hass_config, + ) + ) + + if coordinator_tasks: + hass.data[DOMAIN] = await asyncio.gather(*coordinator_tasks) class TriggerUpdateCoordinator(update_coordinator.DataUpdateCoordinator): @@ -110,16 +127,17 @@ class TriggerUpdateCoordinator(update_coordinator.DataUpdateCoordinator): EVENT_HOMEASSISTANT_START, self._attach_triggers ) - for platform_domain in (SENSOR_DOMAIN,): - self.hass.async_create_task( - discovery.async_load_platform( - self.hass, - platform_domain, - DOMAIN, - {"coordinator": self, "entities": self.config[platform_domain]}, - hass_config, + for platform_domain in PLATFORMS: + if platform_domain in self.config: + self.hass.async_create_task( + discovery.async_load_platform( + self.hass, + platform_domain, + DOMAIN, + {"coordinator": self, "entities": self.config[platform_domain]}, + hass_config, + ) ) - ) async def _attach_triggers(self, start_event=None) -> None: """Attach the triggers.""" diff --git a/homeassistant/components/template/config.py b/homeassistant/components/template/config.py index 5d1a66836f3..8c015d70f1a 100644 --- a/homeassistant/components/template/config.py +++ b/homeassistant/components/template/config.py @@ -3,101 +3,29 @@ import logging import voluptuous as vol -from homeassistant.components.sensor import ( - DEVICE_CLASSES_SCHEMA as SENSOR_DEVICE_CLASSES_SCHEMA, - DOMAIN as SENSOR_DOMAIN, -) +from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN from homeassistant.config import async_log_exception, config_without_domain -from homeassistant.const import ( - CONF_DEVICE_CLASS, - CONF_ENTITY_PICTURE_TEMPLATE, - CONF_FRIENDLY_NAME, - CONF_FRIENDLY_NAME_TEMPLATE, - CONF_ICON, - CONF_ICON_TEMPLATE, - CONF_NAME, - CONF_SENSORS, - CONF_STATE, - CONF_UNIQUE_ID, - CONF_UNIT_OF_MEASUREMENT, - CONF_VALUE_TEMPLATE, -) -from homeassistant.helpers import config_validation as cv, template +from homeassistant.const import CONF_SENSORS, CONF_UNIQUE_ID +from homeassistant.helpers import config_validation as cv from homeassistant.helpers.trigger import async_validate_trigger_config -from .const import ( - CONF_ATTRIBUTE_TEMPLATES, - CONF_ATTRIBUTES, - CONF_AVAILABILITY, - CONF_AVAILABILITY_TEMPLATE, - CONF_PICTURE, - CONF_TRIGGER, - DOMAIN, -) -from .sensor import SENSOR_SCHEMA as PLATFORM_SENSOR_SCHEMA - -LEGACY_SENSOR = { - CONF_ICON_TEMPLATE: CONF_ICON, - CONF_ENTITY_PICTURE_TEMPLATE: CONF_PICTURE, - CONF_AVAILABILITY_TEMPLATE: CONF_AVAILABILITY, - CONF_ATTRIBUTE_TEMPLATES: CONF_ATTRIBUTES, - CONF_FRIENDLY_NAME_TEMPLATE: CONF_NAME, - CONF_FRIENDLY_NAME: CONF_NAME, - CONF_VALUE_TEMPLATE: CONF_STATE, -} - - -SENSOR_SCHEMA = vol.Schema( - { - vol.Optional(CONF_NAME): cv.template, - vol.Required(CONF_STATE): cv.template, - vol.Optional(CONF_ICON): cv.template, - vol.Optional(CONF_PICTURE): cv.template, - vol.Optional(CONF_AVAILABILITY): cv.template, - vol.Optional(CONF_ATTRIBUTES): vol.Schema({cv.string: cv.template}), - vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, - vol.Optional(CONF_DEVICE_CLASS): SENSOR_DEVICE_CLASSES_SCHEMA, - vol.Optional(CONF_UNIQUE_ID): cv.string, - } -) +from . import sensor as sensor_platform +from .const import CONF_TRIGGER, DOMAIN CONFIG_SECTION_SCHEMA = vol.Schema( { vol.Optional(CONF_UNIQUE_ID): cv.string, - vol.Required(CONF_TRIGGER): cv.TRIGGER_SCHEMA, - vol.Optional(SENSOR_DOMAIN): vol.All(cv.ensure_list, [SENSOR_SCHEMA]), - vol.Optional(CONF_SENSORS): cv.schema_with_slug_keys(PLATFORM_SENSOR_SCHEMA), + vol.Optional(CONF_TRIGGER): cv.TRIGGER_SCHEMA, + vol.Optional(SENSOR_DOMAIN): vol.All( + cv.ensure_list, [sensor_platform.SENSOR_SCHEMA] + ), + vol.Optional(CONF_SENSORS): cv.schema_with_slug_keys( + sensor_platform.LEGACY_SENSOR_SCHEMA + ), } ) -def _rewrite_legacy_to_modern_trigger_conf(cfg: dict): - """Rewrite a legacy to a modern trigger-basd conf.""" - logging.getLogger(__name__).warning( - "The entity definition format under template: differs from the platform configuration format. See https://www.home-assistant.io/integrations/template#configuration-for-trigger-based-template-sensors" - ) - sensor = list(cfg[SENSOR_DOMAIN]) if SENSOR_DOMAIN in cfg else [] - - for device_id, entity_cfg in cfg[CONF_SENSORS].items(): - entity_cfg = {**entity_cfg} - - for from_key, to_key in LEGACY_SENSOR.items(): - if from_key not in entity_cfg or to_key in entity_cfg: - continue - - val = entity_cfg.pop(from_key) - if isinstance(val, str): - val = template.Template(val) - entity_cfg[to_key] = val - - if CONF_NAME not in entity_cfg: - entity_cfg[CONF_NAME] = template.Template(device_id) - - sensor.append(entity_cfg) - - return {**cfg, "sensor": sensor} - - async def async_validate_config(hass, config): """Validate config.""" if DOMAIN not in config: @@ -108,15 +36,26 @@ async def async_validate_config(hass, config): for cfg in cv.ensure_list(config[DOMAIN]): try: cfg = CONFIG_SECTION_SCHEMA(cfg) - cfg[CONF_TRIGGER] = await async_validate_trigger_config( - hass, cfg[CONF_TRIGGER] - ) + + if CONF_TRIGGER in cfg: + cfg[CONF_TRIGGER] = await async_validate_trigger_config( + hass, cfg[CONF_TRIGGER] + ) except vol.Invalid as err: async_log_exception(err, DOMAIN, cfg, hass) continue - if CONF_TRIGGER in cfg and CONF_SENSORS in cfg: - cfg = _rewrite_legacy_to_modern_trigger_conf(cfg) + if CONF_SENSORS in cfg: + logging.getLogger(__name__).warning( + "The entity definition format under template: differs from the platform " + "configuration format. See " + "https://www.home-assistant.io/integrations/template#configuration-for-trigger-based-template-sensors" + ) + sensors = list(cfg[SENSOR_DOMAIN]) if SENSOR_DOMAIN in cfg else [] + sensors.extend( + sensor_platform.rewrite_legacy_to_modern_conf(cfg[CONF_SENSORS]) + ) + cfg = {**cfg, "sensor": sensors} config_sections.append(cfg) diff --git a/homeassistant/components/template/const.py b/homeassistant/components/template/const.py index 971d4a864c9..661953bcfa5 100644 --- a/homeassistant/components/template/const.py +++ b/homeassistant/components/template/const.py @@ -24,3 +24,4 @@ PLATFORMS = [ CONF_AVAILABILITY = "availability" CONF_ATTRIBUTES = "attributes" CONF_PICTURE = "picture" +CONF_OBJECT_ID = "object_id" diff --git a/homeassistant/components/template/sensor.py b/homeassistant/components/template/sensor.py index 4631a775847..224756c2012 100644 --- a/homeassistant/components/template/sensor.py +++ b/homeassistant/components/template/sensor.py @@ -16,23 +16,59 @@ from homeassistant.const import ( CONF_ENTITY_PICTURE_TEMPLATE, CONF_FRIENDLY_NAME, CONF_FRIENDLY_NAME_TEMPLATE, + CONF_ICON, CONF_ICON_TEMPLATE, + CONF_NAME, CONF_SENSORS, CONF_STATE, CONF_UNIQUE_ID, CONF_UNIT_OF_MEASUREMENT, CONF_VALUE_TEMPLATE, ) -from homeassistant.core import callback +from homeassistant.core import HomeAssistant, callback from homeassistant.exceptions import TemplateError -from homeassistant.helpers import config_validation as cv +from homeassistant.helpers import config_validation as cv, template from homeassistant.helpers.entity import async_generate_entity_id -from .const import CONF_ATTRIBUTE_TEMPLATES, CONF_AVAILABILITY_TEMPLATE, CONF_TRIGGER +from .const import ( + CONF_ATTRIBUTE_TEMPLATES, + CONF_ATTRIBUTES, + CONF_AVAILABILITY, + CONF_AVAILABILITY_TEMPLATE, + CONF_OBJECT_ID, + CONF_PICTURE, + CONF_TRIGGER, +) from .template_entity import TemplateEntity from .trigger_entity import TriggerEntity -SENSOR_SCHEMA = vol.All( +LEGACY_FIELDS = { + CONF_ICON_TEMPLATE: CONF_ICON, + CONF_ENTITY_PICTURE_TEMPLATE: CONF_PICTURE, + CONF_AVAILABILITY_TEMPLATE: CONF_AVAILABILITY, + CONF_ATTRIBUTE_TEMPLATES: CONF_ATTRIBUTES, + CONF_FRIENDLY_NAME_TEMPLATE: CONF_NAME, + CONF_FRIENDLY_NAME: CONF_NAME, + CONF_VALUE_TEMPLATE: CONF_STATE, +} + + +SENSOR_SCHEMA = vol.Schema( + { + vol.Optional(CONF_NAME): cv.template, + vol.Required(CONF_STATE): cv.template, + vol.Optional(CONF_ICON): cv.template, + vol.Optional(CONF_PICTURE): cv.template, + vol.Optional(CONF_AVAILABILITY): cv.template, + vol.Optional(CONF_ATTRIBUTES): vol.Schema({cv.string: cv.template}), + vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, + vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, + vol.Optional(CONF_UNIQUE_ID): cv.string, + } +) + + +LEGACY_SENSOR_SCHEMA = vol.All( cv.deprecated(ATTR_ENTITY_ID), vol.Schema( { @@ -54,50 +90,78 @@ SENSOR_SCHEMA = vol.All( ) -def trigger_warning(val): - """Warn if a trigger is defined.""" +def extra_validation_checks(val): + """Run extra validation checks.""" if CONF_TRIGGER in val: raise vol.Invalid( "You can only add triggers to template entities if they are defined under `template:`. " "See the template documentation for more information: https://www.home-assistant.io/integrations/template/" ) + if CONF_SENSORS not in val and SENSOR_DOMAIN not in val: + raise vol.Invalid(f"Required key {SENSOR_DOMAIN} not defined") + return val +def rewrite_legacy_to_modern_conf(cfg: dict[str, dict]) -> list[dict]: + """Rewrite a legacy sensor definitions to modern ones.""" + sensors = [] + + for object_id, entity_cfg in cfg.items(): + entity_cfg = {**entity_cfg, CONF_OBJECT_ID: object_id} + + for from_key, to_key in LEGACY_FIELDS.items(): + if from_key not in entity_cfg or to_key in entity_cfg: + continue + + val = entity_cfg.pop(from_key) + if isinstance(val, str): + val = template.Template(val) + entity_cfg[to_key] = val + + if CONF_NAME not in entity_cfg: + entity_cfg[CONF_NAME] = template.Template(object_id) + + sensors.append(entity_cfg) + + return sensors + + PLATFORM_SCHEMA = vol.All( PLATFORM_SCHEMA.extend( { vol.Optional(CONF_TRIGGER): cv.match_all, # to raise custom warning - vol.Required(CONF_SENSORS): cv.schema_with_slug_keys(SENSOR_SCHEMA), + vol.Required(CONF_SENSORS): cv.schema_with_slug_keys(LEGACY_SENSOR_SCHEMA), } ), - trigger_warning, + extra_validation_checks, ) @callback -def _async_create_template_tracking_entities(hass, config): +def _async_create_template_tracking_entities(async_add_entities, hass, definitions): """Create 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(CONF_FRIENDLY_NAME, device) - friendly_name_template = device_config.get(CONF_FRIENDLY_NAME_TEMPLATE) - unit_of_measurement = device_config.get(CONF_UNIT_OF_MEASUREMENT) - device_class = device_config.get(CONF_DEVICE_CLASS) - attribute_templates = device_config.get(CONF_ATTRIBUTE_TEMPLATES, {}) - unique_id = device_config.get(CONF_UNIQUE_ID) + for entity_conf in definitions: + # Still available on legacy + object_id = entity_conf.get(CONF_OBJECT_ID) + + state_template = entity_conf[CONF_STATE] + icon_template = entity_conf.get(CONF_ICON) + entity_picture_template = entity_conf.get(CONF_PICTURE) + availability_template = entity_conf.get(CONF_AVAILABILITY) + friendly_name_template = entity_conf.get(CONF_NAME) + unit_of_measurement = entity_conf.get(CONF_UNIT_OF_MEASUREMENT) + device_class = entity_conf.get(CONF_DEVICE_CLASS) + attribute_templates = entity_conf.get(CONF_ATTRIBUTES, {}) + unique_id = entity_conf.get(CONF_UNIQUE_ID) sensors.append( SensorTemplate( hass, - device, - friendly_name, + object_id, friendly_name_template, unit_of_measurement, state_template, @@ -110,18 +174,29 @@ def _async_create_template_tracking_entities(hass, config): ) ) - return sensors + async_add_entities(sensors) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the template sensors.""" if discovery_info is None: - async_add_entities(_async_create_template_tracking_entities(hass, config)) - else: + _async_create_template_tracking_entities( + async_add_entities, + hass, + rewrite_legacy_to_modern_conf(config[CONF_SENSORS]), + ) + return + + if "coordinator" in discovery_info: async_add_entities( TriggerSensorEntity(hass, discovery_info["coordinator"], config) for config in discovery_info["entities"] ) + return + + _async_create_template_tracking_entities( + async_add_entities, hass, discovery_info["entities"] + ) class SensorTemplate(TemplateEntity, SensorEntity): @@ -129,18 +204,17 @@ class SensorTemplate(TemplateEntity, SensorEntity): def __init__( self, - hass, - device_id, - friendly_name, - friendly_name_template, - unit_of_measurement, - state_template, - icon_template, - entity_picture_template, - availability_template, - device_class, - attribute_templates, - unique_id, + hass: HomeAssistant, + object_id: str | None, + friendly_name_template: template.Template | None, + unit_of_measurement: str | None, + state_template: template.Template, + icon_template: template.Template | None, + entity_picture_template: template.Template | None, + availability_template: template.Template | None, + device_class: str | None, + attribute_templates: dict[str, template.Template], + unique_id: str | None, ): """Initialize the sensor.""" super().__init__( @@ -149,11 +223,22 @@ class SensorTemplate(TemplateEntity, SensorEntity): icon_template=icon_template, entity_picture_template=entity_picture_template, ) - self.entity_id = async_generate_entity_id( - ENTITY_ID_FORMAT, device_id, hass=hass - ) - self._name = friendly_name + if object_id is not None: + self.entity_id = async_generate_entity_id( + ENTITY_ID_FORMAT, object_id, hass=hass + ) + + self._name: str | None = None self._friendly_name_template = friendly_name_template + + # Try to render the name as it can influence the entity ID + if friendly_name_template: + friendly_name_template.hass = hass + try: + self._name = friendly_name_template.async_render(parse_result=False) + except template.TemplateError: + pass + self._unit_of_measurement = unit_of_measurement self._template = state_template self._state = None @@ -164,7 +249,7 @@ class SensorTemplate(TemplateEntity, SensorEntity): async def async_added_to_hass(self): """Register callbacks.""" self.add_template_attribute("_state", self._template, None, self._update_state) - if self._friendly_name_template is not None: + if self._friendly_name_template and not self._friendly_name_template.is_static: self.add_template_attribute("_name", self._friendly_name_template) await super().async_added_to_hass() diff --git a/tests/components/template/test_init.py b/tests/components/template/test_init.py index 0f8dff4026f..3c098a0729f 100644 --- a/tests/components/template/test_init.py +++ b/tests/components/template/test_init.py @@ -28,26 +28,37 @@ async def test_reloadable(hass): }, }, }, - "template": { - "trigger": {"platform": "event", "event_type": "event_1"}, - "sensor": { - "name": "top level", - "state": "{{ trigger.event.data.source }}", + "template": [ + { + "trigger": {"platform": "event", "event_type": "event_1"}, + "sensor": { + "name": "top level", + "state": "{{ trigger.event.data.source }}", + }, }, - }, + { + "sensor": { + "name": "top level state", + "state": "{{ states.sensor.top_level.state }} + 2", + }, + }, + ], }, ) await hass.async_block_till_done() await hass.async_start() await hass.async_block_till_done() + assert hass.states.get("sensor.top_level_state").state == "unknown + 2" hass.bus.async_fire("event_1", {"source": "init"}) await hass.async_block_till_done() - assert len(hass.states.async_all()) == 3 + assert len(hass.states.async_all()) == 4 assert hass.states.get("sensor.state").state == "mytest" assert hass.states.get("sensor.top_level").state == "init" + await hass.async_block_till_done() + assert hass.states.get("sensor.top_level_state").state == "init + 2" yaml_path = path.join( _get_fixtures_base_path(), diff --git a/tests/components/template/test_sensor.py b/tests/components/template/test_sensor.py index d146f5d88de..b510a0c75f8 100644 --- a/tests/components/template/test_sensor.py +++ b/tests/components/template/test_sensor.py @@ -26,7 +26,7 @@ import homeassistant.util.dt as dt_util from tests.common import assert_setup_component, async_fire_time_changed -async def test_template(hass): +async def test_template_legacy(hass): """Test template.""" with assert_setup_component(1, sensor.DOMAIN): assert await async_setup_component(