Move trigger-specific fields into options in new-style triggers (home-assistant#151314)

Author: arturpragacz

homeassistant/components/zwave_js/device_trigger.py

@@ -16,6 +16,7 @@
     CONF_DEVICE_ID,
     CONF_DOMAIN,
     CONF_ENTITY_ID,
+    CONF_OPTIONS,
     CONF_PLATFORM,
     CONF_TYPE,
 )
@@ -434,12 +435,13 @@ async def async_attach_trigger(
 
     if trigger_platform == VALUE_UPDATED_PLATFORM_TYPE:
         zwave_js_config = {
-            state.CONF_PLATFORM: trigger_platform,
-            CONF_DEVICE_ID: config[CONF_DEVICE_ID],
+            CONF_OPTIONS: {
+                CONF_DEVICE_ID: config[CONF_DEVICE_ID],
+            },
         }
         copy_available_params(
             config,
-            zwave_js_config,
+            zwave_js_config[CONF_OPTIONS],
             [
                 ATTR_COMMAND_CLASS,
                 ATTR_PROPERTY,
@@ -453,7 +455,7 @@ async def async_attach_trigger(
             hass, zwave_js_config
         )
         return await attach_value_updated_trigger(
-            hass, zwave_js_config, action, trigger_info
+            hass, zwave_js_config[CONF_OPTIONS], action, trigger_info
         )
 
     raise HomeAssistantError(f"Unhandled trigger type {trigger_type}")

homeassistant/components/zwave_js/triggers/event.py

@@ -15,6 +15,7 @@
     ATTR_CONFIG_ENTRY_ID,
     ATTR_DEVICE_ID,
     ATTR_ENTITY_ID,
+    CONF_OPTIONS,
     CONF_PLATFORM,
 )
 from homeassistant.core import CALLBACK_TYPE, HassJob, HomeAssistant, callback
@@ -25,6 +26,7 @@
     TriggerActionType,
     TriggerData,
     TriggerInfo,
+    move_top_level_schema_fields_to_options,
 )
 from homeassistant.helpers.typing import ConfigType
 
@@ -95,55 +97,37 @@ def validate_event_data(obj: dict) -> dict:
     return obj
 
 
-TRIGGER_SCHEMA = vol.All(
-    cv.TRIGGER_BASE_SCHEMA.extend(
-        {
-            vol.Required(CONF_PLATFORM): PLATFORM_TYPE,
-            vol.Optional(ATTR_CONFIG_ENTRY_ID): str,
-            vol.Optional(ATTR_DEVICE_ID): vol.All(cv.ensure_list, [cv.string]),
-            vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
-            vol.Required(ATTR_EVENT_SOURCE): vol.In(["controller", "driver", "node"]),
-            vol.Required(ATTR_EVENT): cv.string,
-            vol.Optional(ATTR_EVENT_DATA): dict,
-            vol.Optional(ATTR_PARTIAL_DICT_MATCH, default=False): bool,
-        },
-    ),
-    validate_event_name,
-    validate_event_data,
-    vol.Any(
-        validate_non_node_event_source,
-        cv.has_at_least_one_key(ATTR_DEVICE_ID, ATTR_ENTITY_ID),
-    ),
-)
-
-
-async def async_validate_trigger_config(
-    hass: HomeAssistant, config: ConfigType
-) -> ConfigType:
-    """Validate config."""
-    config = TRIGGER_SCHEMA(config)
-
-    if ATTR_CONFIG_ENTRY_ID in config:
-        entry_id = config[ATTR_CONFIG_ENTRY_ID]
-        if hass.config_entries.async_get_entry(entry_id) is None:
-            raise vol.Invalid(f"Config entry '{entry_id}' not found")
-
-    if async_bypass_dynamic_config_validation(hass, config):
-        return config
-
-    if config[ATTR_EVENT_SOURCE] == "node" and not async_get_nodes_from_targets(
-        hass, config
-    ):
-        raise vol.Invalid(
-            f"No nodes found for given {ATTR_DEVICE_ID}s or {ATTR_ENTITY_ID}s."
+_OPTIONS_SCHEMA_DICT = {
+    vol.Optional(ATTR_CONFIG_ENTRY_ID): str,
+    vol.Optional(ATTR_DEVICE_ID): vol.All(cv.ensure_list, [cv.string]),
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Required(ATTR_EVENT_SOURCE): vol.In(["controller", "driver", "node"]),
+    vol.Required(ATTR_EVENT): cv.string,
+    vol.Optional(ATTR_EVENT_DATA): dict,
+    vol.Optional(ATTR_PARTIAL_DICT_MATCH, default=False): bool,
+}
+
+_CONFIG_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_OPTIONS): vol.All(
+            _OPTIONS_SCHEMA_DICT,
+            validate_event_name,
+            validate_event_data,
+            vol.Any(
+                validate_non_node_event_source,
+                cv.has_at_least_one_key(ATTR_DEVICE_ID, ATTR_ENTITY_ID),
+            ),
         )
-
-    return config
+    }
+)
 
 
 class EventTrigger(Trigger):
     """Z-Wave JS event trigger."""
 
+    _hass: HomeAssistant
+    _options: ConfigType
+
     _event_source: str
     _event_name: str
     _event_data_filter: dict
@@ -153,17 +137,43 @@ class EventTrigger(Trigger):
 
     _platform_type = PLATFORM_TYPE
 
-    def __init__(self, hass: HomeAssistant, config: ConfigType) -> None:
-        """Initialize trigger."""
-        self._config = config
-        self._hass = hass
+    @classmethod
+    async def async_validate_complete_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate complete config."""
+        config = move_top_level_schema_fields_to_options(config, _OPTIONS_SCHEMA_DICT)
+        return await super().async_validate_complete_config(hass, config)
 
     @classmethod
     async def async_validate_config(
         cls, hass: HomeAssistant, config: ConfigType
     ) -> ConfigType:
         """Validate config."""
-        return await async_validate_trigger_config(hass, config)
+        config = _CONFIG_SCHEMA(config)
+        options = config[CONF_OPTIONS]
+
+        if ATTR_CONFIG_ENTRY_ID in options:
+            entry_id = options[ATTR_CONFIG_ENTRY_ID]
+            if hass.config_entries.async_get_entry(entry_id) is None:
+                raise vol.Invalid(f"Config entry '{entry_id}' not found")
+
+        if async_bypass_dynamic_config_validation(hass, options):
+            return config
+
+        if options[ATTR_EVENT_SOURCE] == "node" and not async_get_nodes_from_targets(
+            hass, options
+        ):
+            raise vol.Invalid(
+                f"No nodes found for given {ATTR_DEVICE_ID}s or {ATTR_ENTITY_ID}s."
+            )
+
+        return config
+
+    def __init__(self, hass: HomeAssistant, config: ConfigType) -> None:
+        """Initialize trigger."""
+        self._hass = hass
+        self._options = config[CONF_OPTIONS]
 
     async def async_attach(
         self,
@@ -172,17 +182,17 @@ async def async_attach(
     ) -> CALLBACK_TYPE:
         """Attach a trigger."""
         dev_reg = dr.async_get(self._hass)
-        config = self._config
-        if config[ATTR_EVENT_SOURCE] == "node" and not async_get_nodes_from_targets(
-            self._hass, config, dev_reg=dev_reg
+        options = self._options
+        if options[ATTR_EVENT_SOURCE] == "node" and not async_get_nodes_from_targets(
+            self._hass, options, dev_reg=dev_reg
         ):
             raise ValueError(
                 f"No nodes found for given {ATTR_DEVICE_ID}s or {ATTR_ENTITY_ID}s."
             )
 
-        self._event_source = config[ATTR_EVENT_SOURCE]
-        self._event_name = config[ATTR_EVENT]
-        self._event_data_filter = config.get(ATTR_EVENT_DATA, {})
+        self._event_source = options[ATTR_EVENT_SOURCE]
+        self._event_name = options[ATTR_EVENT]
+        self._event_data_filter = options.get(ATTR_EVENT_DATA, {})
         self._job = HassJob(action)
         self._trigger_data = trigger_info["trigger_data"]
         self._unsubs: list[Callable] = []
@@ -199,7 +209,7 @@ def _async_on_event(
             if key not in event_data:
                 return
             if (
-                self._config[ATTR_PARTIAL_DICT_MATCH]
+                self._options[ATTR_PARTIAL_DICT_MATCH]
                 and isinstance(event_data[key], dict)
                 and isinstance(val, dict)
             ):
@@ -255,10 +265,10 @@ def _create_zwave_listeners(self) -> None:
         dev_reg = dr.async_get(self._hass)
         if not (
             nodes := async_get_nodes_from_targets(
-                self._hass, self._config, dev_reg=dev_reg
+                self._hass, self._options, dev_reg=dev_reg
             )
         ):
-            entry_id = self._config[ATTR_CONFIG_ENTRY_ID]
+            entry_id = self._options[ATTR_CONFIG_ENTRY_ID]
             entry = self._hass.config_entries.async_get_entry(entry_id)
             assert entry
             client = entry.runtime_data.client

homeassistant/components/zwave_js/triggers/value_updated.py

@@ -10,11 +10,22 @@
 from zwave_js_server.model.driver import Driver
 from zwave_js_server.model.value import Value, get_value_id_str
 
-from homeassistant.const import ATTR_DEVICE_ID, ATTR_ENTITY_ID, CONF_PLATFORM, MATCH_ALL
+from homeassistant.const import (
+    ATTR_DEVICE_ID,
+    ATTR_ENTITY_ID,
+    CONF_OPTIONS,
+    CONF_PLATFORM,
+    MATCH_ALL,
+)
 from homeassistant.core import CALLBACK_TYPE, HassJob, HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.trigger import Trigger, TriggerActionType, TriggerInfo
+from homeassistant.helpers.trigger import (
+    Trigger,
+    TriggerActionType,
+    TriggerInfo,
+    move_top_level_schema_fields_to_options,
+)
 from homeassistant.helpers.typing import ConfigType
 
 from ..config_validation import VALUE_SCHEMA
@@ -46,40 +57,40 @@
 ATTR_FROM = "from"
 ATTR_TO = "to"
 
-TRIGGER_SCHEMA = vol.All(
-    cv.TRIGGER_BASE_SCHEMA.extend(
-        {
-            vol.Required(CONF_PLATFORM): PLATFORM_TYPE,
-            vol.Optional(ATTR_DEVICE_ID): vol.All(cv.ensure_list, [cv.string]),
-            vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
-            vol.Required(ATTR_COMMAND_CLASS): vol.In(
-                {cc.value: cc.name for cc in CommandClass}
-            ),
-            vol.Required(ATTR_PROPERTY): vol.Any(vol.Coerce(int), cv.string),
-            vol.Optional(ATTR_ENDPOINT): vol.Coerce(int),
-            vol.Optional(ATTR_PROPERTY_KEY): vol.Any(vol.Coerce(int), cv.string),
-            vol.Optional(ATTR_FROM, default=MATCH_ALL): vol.Any(
-                VALUE_SCHEMA, [VALUE_SCHEMA]
-            ),
-            vol.Optional(ATTR_TO, default=MATCH_ALL): vol.Any(
-                VALUE_SCHEMA, [VALUE_SCHEMA]
-            ),
-        },
+_OPTIONS_SCHEMA_DICT = {
+    vol.Optional(ATTR_DEVICE_ID): vol.All(cv.ensure_list, [cv.string]),
+    vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
+    vol.Required(ATTR_COMMAND_CLASS): vol.In(
+        {cc.value: cc.name for cc in CommandClass}
     ),
-    cv.has_at_least_one_key(ATTR_ENTITY_ID, ATTR_DEVICE_ID),
+    vol.Required(ATTR_PROPERTY): vol.Any(vol.Coerce(int), cv.string),
+    vol.Optional(ATTR_ENDPOINT): vol.Coerce(int),
+    vol.Optional(ATTR_PROPERTY_KEY): vol.Any(vol.Coerce(int), cv.string),
+    vol.Optional(ATTR_FROM, default=MATCH_ALL): vol.Any(VALUE_SCHEMA, [VALUE_SCHEMA]),
+    vol.Optional(ATTR_TO, default=MATCH_ALL): vol.Any(VALUE_SCHEMA, [VALUE_SCHEMA]),
+}
+
+_CONFIG_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_OPTIONS): vol.All(
+            _OPTIONS_SCHEMA_DICT,
+            cv.has_at_least_one_key(ATTR_ENTITY_ID, ATTR_DEVICE_ID),
+        ),
+    },
 )
 
 
 async def async_validate_trigger_config(
     hass: HomeAssistant, config: ConfigType
 ) -> ConfigType:
     """Validate config."""
-    config = TRIGGER_SCHEMA(config)
+    config = _CONFIG_SCHEMA(config)
+    options = config[CONF_OPTIONS]
 
-    if async_bypass_dynamic_config_validation(hass, config):
+    if async_bypass_dynamic_config_validation(hass, options):
         return config
 
-    if not async_get_nodes_from_targets(hass, config):
+    if not async_get_nodes_from_targets(hass, options):
         raise vol.Invalid(
             f"No nodes found for given {ATTR_DEVICE_ID}s or {ATTR_ENTITY_ID}s."
         )
@@ -88,25 +99,25 @@ async def async_validate_trigger_config(
 
 async def async_attach_trigger(
     hass: HomeAssistant,
-    config: ConfigType,
+    options: ConfigType,
     action: TriggerActionType,
     trigger_info: TriggerInfo,
     *,
     platform_type: str = PLATFORM_TYPE,
 ) -> CALLBACK_TYPE:
     """Listen for state changes based on configuration."""
     dev_reg = dr.async_get(hass)
-    if not async_get_nodes_from_targets(hass, config, dev_reg=dev_reg):
+    if not async_get_nodes_from_targets(hass, options, dev_reg=dev_reg):
         raise ValueError(
             f"No nodes found for given {ATTR_DEVICE_ID}s or {ATTR_ENTITY_ID}s."
         )
 
-    from_value = config[ATTR_FROM]
-    to_value = config[ATTR_TO]
-    command_class = config[ATTR_COMMAND_CLASS]
-    property_ = config[ATTR_PROPERTY]
-    endpoint = config.get(ATTR_ENDPOINT)
-    property_key = config.get(ATTR_PROPERTY_KEY)
+    from_value = options[ATTR_FROM]
+    to_value = options[ATTR_TO]
+    command_class = options[ATTR_COMMAND_CLASS]
+    property_ = options[ATTR_PROPERTY]
+    endpoint = options.get(ATTR_ENDPOINT)
+    property_key = options.get(ATTR_PROPERTY_KEY)
     unsubs: list[Callable] = []
     job = HassJob(action)
 
@@ -174,7 +185,7 @@ def _create_zwave_listeners() -> None:
         # Nodes list can come from different drivers and we will need to listen to
         # server connections for all of them.
         drivers: set[Driver] = set()
-        for node in async_get_nodes_from_targets(hass, config, dev_reg=dev_reg):
+        for node in async_get_nodes_from_targets(hass, options, dev_reg=dev_reg):
             driver = node.client.driver
             assert driver is not None  # The node comes from the driver.
             drivers.add(driver)
@@ -210,10 +221,16 @@ def _create_zwave_listeners() -> None:
 class ValueUpdatedTrigger(Trigger):
     """Z-Wave JS value updated trigger."""
 
-    def __init__(self, hass: HomeAssistant, config: ConfigType) -> None:
-        """Initialize trigger."""
-        self._config = config
-        self._hass = hass
+    _hass: HomeAssistant
+    _options: ConfigType
+
+    @classmethod
+    async def async_validate_complete_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate complete config."""
+        config = move_top_level_schema_fields_to_options(config, _OPTIONS_SCHEMA_DICT)
+        return await super().async_validate_complete_config(hass, config)
 
     @classmethod
     async def async_validate_config(
@@ -222,12 +239,17 @@ async def async_validate_config(
         """Validate config."""
         return await async_validate_trigger_config(hass, config)
 
+    def __init__(self, hass: HomeAssistant, config: ConfigType) -> None:
+        """Initialize trigger."""
+        self._hass = hass
+        self._options = config[CONF_OPTIONS]
+
     async def async_attach(
         self,
         action: TriggerActionType,
         trigger_info: TriggerInfo,
     ) -> CALLBACK_TYPE:
         """Attach a trigger."""
         return await async_attach_trigger(
-            self._hass, self._config, action, trigger_info
+            self._hass, self._options, action, trigger_info
         )