Allow top level non-trigger template entities (#48976)

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):
+    async def init_coordinator(hass, conf_section):
-        coordinator = TriggerUpdateCoordinator(hass, conf)
+        coordinator = TriggerUpdateCoordinator(hass, conf_section)
-        await coordinator.async_setup(config)
+        await coordinator.async_setup(hass_config)
         return coordinator
 
-    hass.data[DOMAIN] = await asyncio.gather(
+    coordinator_tasks = []
-        *[init_coordinator(hass, conf) for conf in config[DOMAIN]]
+
-    )
+    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,):
+        for platform_domain in PLATFORMS:
-            self.hass.async_create_task(
+            if platform_domain in self.config:
-                discovery.async_load_platform(
+                self.hass.async_create_task(
-                    self.hass,
+                    discovery.async_load_platform(
-                    platform_domain,
+                        self.hass,
-                    DOMAIN,
+                        platform_domain,
-                    {"coordinator": self, "entities": self.config[platform_domain]},
+                        DOMAIN,
-                    hass_config,
+                        {"coordinator": self, "entities": self.config[platform_domain]},
+                        hass_config,
+                    )
                 )
-            )
 
     async def _attach_triggers(self, start_event=None) -> None:
         """Attach the triggers."""

homeassistant/components/template/config.py

@@ -3,101 +3,29 @@ import logging
 
 import voluptuous as vol
 
-from homeassistant.components.sensor import (
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
-    DEVICE_CLASSES_SCHEMA as SENSOR_DEVICE_CLASSES_SCHEMA,
-    DOMAIN as SENSOR_DOMAIN,
-)
 from homeassistant.config import async_log_exception, config_without_domain
-from homeassistant.const import (
+from homeassistant.const import CONF_SENSORS, CONF_UNIQUE_ID
-    CONF_DEVICE_CLASS,
+from homeassistant.helpers import config_validation as cv
-    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.helpers.trigger import async_validate_trigger_config
 
-from .const import (
+from . import sensor as sensor_platform
-    CONF_ATTRIBUTE_TEMPLATES,
+from .const import CONF_TRIGGER, DOMAIN
-    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,
-    }
-)
 
 CONFIG_SECTION_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_UNIQUE_ID): cv.string,
-        vol.Required(CONF_TRIGGER): cv.TRIGGER_SCHEMA,
+        vol.Optional(CONF_TRIGGER): cv.TRIGGER_SCHEMA,
-        vol.Optional(SENSOR_DOMAIN): vol.All(cv.ensure_list, [SENSOR_SCHEMA]),
+        vol.Optional(SENSOR_DOMAIN): vol.All(
-        vol.Optional(CONF_SENSORS): cv.schema_with_slug_keys(PLATFORM_SENSOR_SCHEMA),
+            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:
+        if CONF_SENSORS in cfg:
-            cfg = _rewrite_legacy_to_modern_trigger_conf(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)
 

homeassistant/components/template/const.py

@@ -24,3 +24,4 @@ PLATFORMS = [
 CONF_AVAILABILITY = "availability"
 CONF_ATTRIBUTES = "attributes"
 CONF_PICTURE = "picture"
+CONF_OBJECT_ID = "object_id"

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):
+def extra_validation_checks(val):
-    """Warn if a trigger is defined."""
+    """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():
+    for entity_conf in definitions:
-        state_template = device_config[CONF_VALUE_TEMPLATE]
+        # Still available on legacy
-        icon_template = device_config.get(CONF_ICON_TEMPLATE)
+        object_id = entity_conf.get(CONF_OBJECT_ID)
-        entity_picture_template = device_config.get(CONF_ENTITY_PICTURE_TEMPLATE)
+
-        availability_template = device_config.get(CONF_AVAILABILITY_TEMPLATE)
+        state_template = entity_conf[CONF_STATE]
-        friendly_name = device_config.get(CONF_FRIENDLY_NAME, device)
+        icon_template = entity_conf.get(CONF_ICON)
-        friendly_name_template = device_config.get(CONF_FRIENDLY_NAME_TEMPLATE)
+        entity_picture_template = entity_conf.get(CONF_PICTURE)
-        unit_of_measurement = device_config.get(CONF_UNIT_OF_MEASUREMENT)
+        availability_template = entity_conf.get(CONF_AVAILABILITY)
-        device_class = device_config.get(CONF_DEVICE_CLASS)
+        friendly_name_template = entity_conf.get(CONF_NAME)
-        attribute_templates = device_config.get(CONF_ATTRIBUTE_TEMPLATES, {})
+        unit_of_measurement = entity_conf.get(CONF_UNIT_OF_MEASUREMENT)
-        unique_id = device_config.get(CONF_UNIQUE_ID)
+        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,
+                object_id,
-                friendly_name,
                 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))
+        _async_create_template_tracking_entities(
-    else:
+            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,
+        hass: HomeAssistant,
-        device_id,
+        object_id: str | None,
-        friendly_name,
+        friendly_name_template: template.Template | None,
-        friendly_name_template,
+        unit_of_measurement: str | None,
-        unit_of_measurement,
+        state_template: template.Template,
-        state_template,
+        icon_template: template.Template | None,
-        icon_template,
+        entity_picture_template: template.Template | None,
-        entity_picture_template,
+        availability_template: template.Template | None,
-        availability_template,
+        device_class: str | None,
-        device_class,
+        attribute_templates: dict[str, template.Template],
-        attribute_templates,
+        unique_id: str | None,
-        unique_id,
     ):
         """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(
+        if object_id is not None:
-            ENTITY_ID_FORMAT, device_id, hass=hass
+            self.entity_id = async_generate_entity_id(
-        )
+                ENTITY_ID_FORMAT, object_id, hass=hass
-        self._name = friendly_name
+            )
+
+        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()

tests/components/template/test_init.py

@@ -28,26 +28,37 @@ async def test_reloadable(hass):
                     },
                 },
             },
-            "template": {
+            "template": [
-                "trigger": {"platform": "event", "event_type": "event_1"},
+                {
-                "sensor": {
+                    "trigger": {"platform": "event", "event_type": "event_1"},
-                    "name": "top level",
+                    "sensor": {
-                    "state": "{{ trigger.event.data.source }}",
+                        "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(),

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(