Fix context filtering

homeassistant/components/automation/__init__.py

@@ -143,6 +143,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "cover",
     "device_tracker",
     "door",
+    "event",
     "fan",
     "garage_door",
     "humidifier",

homeassistant/components/event/icons.json

@@ -12,5 +12,10 @@
     "motion": {
       "default": "mdi:motion-sensor"
     }
+  },
+  "triggers": {
+    "received": {
+      "trigger": "mdi:eye-check"
+    }
   }
 }

homeassistant/components/event/strings.json

@@ -21,5 +21,17 @@
       "name": "Motion"
     }
   },
-  "title": "Event"
+  "title": "Event",
+  "triggers": {
+    "received": {
+      "description": "Triggers after one or more event entities receive a matching event.",
+      "fields": {
+        "event_type": {
+          "description": "The event types to trigger on.",
+          "name": "Event type"
+        }
+      },
+      "name": "Event received"
+    }
+  }
 }

homeassistant/components/event/trigger.py

@@ -0,0 +1,53 @@
+"""Provides triggers for events."""
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_OPTIONS
+from homeassistant.core import HomeAssistant, State
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    EntityTriggerBase,
+    Trigger,
+    TriggerConfig,
+)
+
+from .const import ATTR_EVENT_TYPE, DOMAIN
+
+CONF_EVENT_TYPE = "event_type"
+
+EVENT_RECEIVED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
+    {
+        vol.Required(CONF_OPTIONS): {
+            vol.Required(CONF_EVENT_TYPE): vol.All(
+                cv.ensure_list, vol.Length(min=1), [cv.string]
+            ),
+        },
+    }
+)
+
+
+class EventReceivedTrigger(EntityTriggerBase):
+    """Trigger for event entity when it receives a matching event."""
+
+    _domains = {DOMAIN}
+    _schema = EVENT_RECEIVED_TRIGGER_SCHEMA
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the event received trigger."""
+        super().__init__(hass, config)
+        self._event_types = set(self._options[CONF_EVENT_TYPE])
+
+    def is_valid_state(self, state: State) -> bool:
+        """Check if the event type matches one of the configured types."""
+        return state.attributes.get(ATTR_EVENT_TYPE) in self._event_types
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "received": EventReceivedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for events."""
+    return TRIGGERS

homeassistant/components/event/triggers.yaml

@@ -0,0 +1,16 @@
+received:
+  target:
+    entity:
+      domain: event
+  fields:
+    event_type:
+      context:
+        filter_target: target
+      required: true
+      selector:
+        state:
+          attribute: event_type
+          hide_states:
+            - unavailable
+            - unknown
+          multiple: true

homeassistant/helpers/selector.py

@@ -1517,11 +1517,7 @@ class StateSelector(Selector[StateSelectorConfig]):
         {
             vol.Optional("entity_id"): cv.entity_id,
             vol.Optional("hide_states"): [str],
-            # The attribute to filter on, is currently deliberately not
-            # configurable/exposed. We are considering separating state
-            # selectors into two types: one for state and one for attribute.
-            # Limiting the public use, prevents breaking changes in the future.
-            # vol.Optional("attribute"): str,
+            vol.Optional("attribute"): str,
             vol.Optional("multiple", default=False): cv.boolean,
         }
     )

homeassistant/helpers/trigger.py

@@ -1114,7 +1114,10 @@ async def _async_get_trigger_platform(
 
     platform_and_sub_type = trigger_key.split(".")
     platform = platform_and_sub_type[0]
-    platform = _PLATFORM_ALIASES.get(platform, platform)
+    # Only apply aliases for old-style triggers (no sub_type).
+    # New-style triggers (e.g. "event.received") use the integration domain directly.
+    if len(platform_and_sub_type) == 1:
+        platform = _PLATFORM_ALIASES.get(platform, platform)
 
     if automation.is_disabled_experimental_trigger(hass, platform):
         raise vol.Invalid(

tests/components/event/test_trigger.py

@@ -0,0 +1,286 @@
+"""Test event trigger."""
+
+import pytest
+
+from homeassistant.components.event.const import ATTR_EVENT_TYPE
+from homeassistant.const import (
+    ATTR_LABEL_ID,
+    CONF_ENTITY_ID,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
+from homeassistant.core import HomeAssistant, ServiceCall
+
+from tests.components import (
+    TriggerStateDescription,
+    arm_trigger,
+    parametrize_target_entities,
+    set_or_remove_state,
+    target_entities,
+)
+
+
+@pytest.fixture
+async def target_events(hass: HomeAssistant) -> list[str]:
+    """Create multiple event entities associated with different targets."""
+    return (await target_entities(hass, "event"))["included"]
+
+
+@pytest.mark.parametrize("trigger_key", ["event.received"])
+async def test_event_triggers_gated_by_labs_flag(
+    hass: HomeAssistant, caplog: pytest.LogCaptureFixture, trigger_key: str
+) -> None:
+    """Test the event triggers are gated by the labs flag."""
+    await arm_trigger(hass, trigger_key, None, {ATTR_LABEL_ID: "test_label"})
+    assert (
+        "Unnamed automation failed to setup triggers and has been disabled: Trigger "
+        f"'{trigger_key}' requires the experimental 'New triggers and conditions' "
+        "feature to be enabled in Home Assistant Labs settings (feature flag: "
+        "'new_triggers_conditions')"
+    ) in caplog.text
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("event"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        # Event received with matching event_type
+        (
+            "event.received",
+            {"event_type": ["button_press"]},
+            [
+                {"included": {"state": None, "attributes": {}}, "count": 0},
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:00.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:01.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 1,
+                },
+            ],
+        ),
+        # Event received with non-matching event_type then matching
+        (
+            "event.received",
+            {"event_type": ["button_press"]},
+            [
+                {"included": {"state": None, "attributes": {}}, "count": 0},
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:00.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "other_event"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:01.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 1,
+                },
+            ],
+        ),
+        # Multiple event types configured
+        (
+            "event.received",
+            {"event_type": ["button_press", "button_long_press"]},
+            [
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:00.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:01.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_long_press"},
+                    },
+                    "count": 1,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:02.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "other_event"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:03.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 1,
+                },
+            ],
+        ),
+        # From unavailable - first valid state after unavailable is not triggered
+        (
+            "event.received",
+            {"event_type": ["button_press"]},
+            [
+                {
+                    "included": {
+                        "state": STATE_UNAVAILABLE,
+                        "attributes": {},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:00.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:01.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 1,
+                },
+            ],
+        ),
+        # From unknown - first valid state after unknown is not triggered
+        (
+            "event.received",
+            {"event_type": ["button_press"]},
+            [
+                {
+                    "included": {
+                        "state": STATE_UNKNOWN,
+                        "attributes": {},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:00.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:01.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 1,
+                },
+            ],
+        ),
+        # Same event type fires again (different timestamps)
+        (
+            "event.received",
+            {"event_type": ["button_press"]},
+            [
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:00.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:01.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 1,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:02.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 1,
+                },
+            ],
+        ),
+        # To unavailable - should not trigger, and first state after unavailable is skipped
+        (
+            "event.received",
+            {"event_type": ["button_press"]},
+            [
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:00.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": STATE_UNAVAILABLE,
+                        "attributes": {},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:01.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 0,
+                },
+                {
+                    "included": {
+                        "state": "2026-01-01T00:00:02.000+00:00",
+                        "attributes": {ATTR_EVENT_TYPE: "button_press"},
+                    },
+                    "count": 1,
+                },
+            ],
+        ),
+    ],
+)
+async def test_event_state_trigger_behavior_any(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_events: list[str],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict,
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test that the event trigger fires when an event entity receives a matching event."""
+    other_entity_ids = set(target_events) - {entity_id}
+
+    # Set all events to the initial state
+    for eid in target_events:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, trigger_options, trigger_target_config)
+
+    for state in states[1:]:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        # Check if changing other events also triggers
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == (entities_in_target - 1) * state["count"]
+        service_calls.clear()