Refactor condition API (#168815)

Co-authored-by: Artur Pragacz <artur@pragacz.com>

Author: emontnemery

homeassistant/components/device_automation/condition.py

@@ -11,7 +11,6 @@
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.condition import (
     Condition,
-    ConditionChecker,
     ConditionCheckerType,
     ConditionConfig,
 )
@@ -54,6 +53,7 @@ class DeviceCondition(Condition):
     """Device condition."""
 
     _config: ConfigType
+    _platform_checker: ConditionCheckerType
 
     @classmethod
     async def async_validate_complete_config(
@@ -87,20 +87,19 @@ def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
         assert config.options is not None
         self._config = config.options
 
-    async def async_get_checker(self) -> ConditionChecker:
-        """Test a device condition."""
+    async def async_setup(self) -> None:
+        """Set up a device condition."""
         platform = await async_get_device_automation_platform(
             self._hass, self._config[CONF_DOMAIN], DeviceAutomationType.CONDITION
         )
-        platform_checker = platform.async_condition_from_config(
+        self._platform_checker = platform.async_condition_from_config(
             self._hass, self._config
         )
 
-        def checker(variables: TemplateVarsType = None, **kwargs: Any) -> bool:
-            result = platform_checker(self._hass, variables)
-            return result is not False
-
-        return checker
+    def _async_check(self, variables: TemplateVarsType = None, **kwargs: Any) -> bool:
+        """Check the condition."""
+        result = self._platform_checker(self._hass, variables)
+        return result is not False
 
 
 CONDITIONS: dict[str, type[Condition]] = {

homeassistant/components/sun/condition.py

@@ -13,7 +13,6 @@
 from homeassistant.helpers.automation import move_top_level_schema_fields_to_options
 from homeassistant.helpers.condition import (
     Condition,
-    ConditionChecker,
     ConditionCheckParams,
     ConditionConfig,
     condition_trace_set_result,
@@ -151,19 +150,20 @@ def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
         super().__init__(hass, config)
         assert config.options is not None
         self._options = config.options
-
-    async def async_get_checker(self) -> ConditionChecker:
-        """Wrap action method with sun based condition."""
-        before = self._options.get("before")
-        after = self._options.get("after")
-        before_offset = self._options.get("before_offset")
-        after_offset = self._options.get("after_offset")
-
-        def sun_if(**kwargs: Unpack[ConditionCheckParams]) -> bool:
-            """Validate time based if-condition."""
-            return sun(self._hass, before, after, before_offset, after_offset)
-
-        return sun_if
+        self._before = self._options.get("before")
+        self._after = self._options.get("after")
+        self._before_offset = self._options.get("before_offset")
+        self._after_offset = self._options.get("after_offset")
+
+    def _async_check(self, **kwargs: Unpack[ConditionCheckParams]) -> bool:
+        """Check the condition."""
+        return sun(
+            self._hass,
+            self._before,
+            self._after,
+            self._before_offset,
+            self._after_offset,
+        )
 
 
 CONDITIONS: dict[str, type[Condition]] = {

homeassistant/components/zone/condition.py

@@ -22,7 +22,6 @@
 from homeassistant.helpers.automation import move_top_level_schema_fields_to_options
 from homeassistant.helpers.condition import (
     Condition,
-    ConditionChecker,
     ConditionCheckParams,
     ConditionConfig,
 )
@@ -117,44 +116,39 @@ def __init__(self, hass: HomeAssistant, config: ConditionConfig) -> None:
         super().__init__(hass, config)
         assert config.options is not None
         self._options = config.options
-
-    async def async_get_checker(self) -> ConditionChecker:
-        """Wrap action method with zone based condition."""
-        entity_ids = self._options.get(CONF_ENTITY_ID, [])
-        zone_entity_ids = self._options.get(CONF_ZONE, [])
-
-        def if_in_zone(**kwargs: Unpack[ConditionCheckParams]) -> bool:
-            """Test if condition."""
-            errors = []
-
-            all_ok = True
-            for entity_id in entity_ids:
-                entity_ok = False
-                for zone_entity_id in zone_entity_ids:
-                    try:
-                        if zone(self._hass, zone_entity_id, entity_id):
-                            entity_ok = True
-                    except ConditionErrorMessage as ex:
-                        errors.append(
-                            ConditionErrorMessage(
-                                "zone",
-                                (
-                                    f"error matching {entity_id} with {zone_entity_id}:"
-                                    f" {ex.message}"
-                                ),
-                            )
+        self._entity_ids = self._options.get(CONF_ENTITY_ID, [])
+        self._zone_entity_ids = self._options.get(CONF_ZONE, [])
+
+    def _async_check(self, **kwargs: Unpack[ConditionCheckParams]) -> bool:
+        """Test if condition."""
+        errors = []
+
+        all_ok = True
+        for entity_id in self._entity_ids:
+            entity_ok = False
+            for zone_entity_id in self._zone_entity_ids:
+                try:
+                    if zone(self._hass, zone_entity_id, entity_id):
+                        entity_ok = True
+                except ConditionErrorMessage as ex:
+                    errors.append(
+                        ConditionErrorMessage(
+                            "zone",
+                            (
+                                f"error matching {entity_id} with {zone_entity_id}:"
+                                f" {ex.message}"
+                            ),
                         )
+                    )
 
-                if not entity_ok:
-                    all_ok = False
-
-            # Raise the errors only if no definitive result was found
-            if errors and not all_ok:
-                raise ConditionErrorContainer("zone", errors=errors)
+            if not entity_ok:
+                all_ok = False
 
-            return all_ok
+        # Raise the errors only if no definitive result was found
+        if errors and not all_ok:
+            raise ConditionErrorContainer("zone", errors=errors)
 
-        return if_in_zone
+        return all_ok
 
 
 CONDITIONS: dict[str, type[Condition]] = {