use CallResultHandlerDecorator for webhook response future

Address PR review feedback: instead of adding a new result_future
field to DispatchData, route the response future through the existing
CallResultHandlerDecorator pipeline.

Author: JayNewstrom

custom_components/pyscript/decorator.py

@@ -264,7 +264,6 @@ async def _call(self, data: DispatchData) -> None:
                 # notify handlers with "None"
                 for result_handler_dec in result_handlers:
                     await result_handler_dec.handle_call_result(data, None)
-                data.set_result(None)
                 return
         # Fire an event indicating that pyscript is running
         # Note: the event must have an entity_id for logbook to work correctly.
@@ -280,9 +279,9 @@ async def _call(self, data: DispatchData) -> None:
             result = await data.call_ast_ctx.call_func(self.eval_func, None, **data.func_args)
             for result_handler_dec in result_handlers:
                 await result_handler_dec.handle_call_result(data, result)
-            data.set_result(result)
         except Exception as e:
-            data.set_result(None)
+            for result_handler_dec in result_handlers:
+                await result_handler_dec.handle_call_result(data, None)
             await self.handle_exception(e)
 
     async def dispatch(self, data: DispatchData) -> None:
@@ -293,7 +292,8 @@ async def dispatch(self, data: DispatchData) -> None:
         for dec in decorators:
             if await dec.handle_dispatch(data) is False:
                 self.logger.debug("Trigger not active due to %s", dec)
-                data.set_result(None)
+                for result_handler_dec in self.get_decorators(CallResultHandlerDecorator):
+                    await result_handler_dec.handle_call_result(data, None)
                 return
 
         action_ast_ctx = AstEval(

custom_components/pyscript/decorator_abc.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-import asyncio
 from dataclasses import dataclass, field
 from enum import StrEnum
 import logging
@@ -47,16 +46,6 @@ class DispatchData:
     call_ast_ctx: AstEval | None = field(default=None, kw_only=True)
     hass_context: Context | None = field(default=None, kw_only=True)
 
-    # When set, the dispatch pipeline resolves this future with the
-    # decorated function's return value. Resolved with None if the
-    # function is skipped (guard rejection) or raises.
-    result_future: asyncio.Future[Any] | None = field(default=None, kw_only=True)
-
-    def set_result(self, value: Any) -> None:
-        """Resolve result_future with value if it is still pending."""
-        if self.result_future is not None and not self.result_future.done():
-            self.result_future.set_result(value)
-
 
 class Decorator(ABC):
     """Generic decorator abstraction."""

custom_components/pyscript/decorators/webhook.py

@@ -13,13 +13,15 @@
 from homeassistant.components.webhook import SUPPORTED_METHODS
 from homeassistant.helpers import config_validation as cv
 
-from ..decorator_abc import DispatchData, TriggerDecorator
+from ..decorator_abc import CallResultHandlerDecorator, DispatchData, TriggerDecorator
 from .base import AutoKwargsDecorator, ExpressionDecorator
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class WebhookTriggerDecorator(TriggerDecorator, ExpressionDecorator, AutoKwargsDecorator):
+class WebhookTriggerDecorator(
+    TriggerDecorator, ExpressionDecorator, AutoKwargsDecorator, CallResultHandlerDecorator
+):
     """Implementation for @webhook_trigger."""
 
     name = "webhook_trigger"
@@ -41,6 +43,7 @@ class WebhookTriggerDecorator(TriggerDecorator, ExpressionDecorator, AutoKwargsD
     local_only: bool
     methods: set[str]
     sets_http_response_code: bool
+    future: asyncio.Future[Any] | None = None
 
     webhook_id2triggers: ClassVar[dict[str, set[WebhookTriggerDecorator]]] = {}
 
@@ -75,10 +78,11 @@ async def _handler(hass, webhook_id, request):
                 if not await trigger.check_expression_vars(trigger_args):
                     continue
             future: asyncio.Future[Any] = hass.loop.create_future()
+            trigger.future = future
             if trigger.sets_http_response_code:
                 response_future = future
             futures.append(future)
-            await trigger.dispatch(DispatchData(trigger_args, result_future=future))
+            await trigger.dispatch(DispatchData(trigger_args))
 
         if not futures:
             return None
@@ -89,6 +93,14 @@ async def _handler(hass, webhook_id, request):
             return None
         return WebhookTriggerDecorator.coerce_response(response_future.result())
 
+    async def handle_call_result(self, data: DispatchData, result: Any) -> None:
+        """Resolve the response future with the decorated function's return value."""
+        if data.trigger is not self:
+            return
+        response_future = self.future
+        if response_future is not None and not response_future.done():
+            response_future.set_result(result)
+
     @staticmethod
     def coerce_response(value: Any) -> web.Response | None:
         """Convert a webhook function return value to an aiohttp Response."""

tests/test_decorator_manager.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
 from typing import ClassVar
 from unittest.mock import patch
@@ -354,14 +353,12 @@ def make_dispatch_data(
     *,
     call_ast_ctx: DummyCallAstCtx | None = None,
     hass_context: Context | None = None,
-    result_future: asyncio.Future | None = None,
 ) -> DispatchData:
     """Build DispatchData from test doubles."""
     return DispatchData(
         func_args,
         call_ast_ctx=call_ast_ctx,
         hass_context=hass_context,
-        result_future=result_future,
     )
 
 
@@ -607,59 +604,14 @@ async def test_function_decorator_manager_logs_call_exception(hass):
 
 
 @pytest.mark.asyncio
-async def test_function_decorator_manager_result_future_success(hass):
-    """Successful calls should resolve result_future with the function's return value."""
-    DecoratorManager.hass = hass
-    manager = FunctionDecoratorManager(DummyAstCtx(), DummyEvalFuncVar())
-    call_ast_ctx = DummyCallAstCtx(result=201)
-    future: asyncio.Future = hass.loop.create_future()
-
-    with patch.object(Function, "store_hass_context"):
-        await call_function_manager(
-            manager,
-            make_dispatch_data(
-                {"arg1": 1},
-                call_ast_ctx=call_ast_ctx,
-                hass_context=Context(id="call-parent"),
-                result_future=future,
-            ),
-        )
-        await hass.async_block_till_done()
-
-    assert future.done()
-    assert future.result() == 201
-
-
-@pytest.mark.asyncio
-async def test_function_decorator_manager_result_future_cancel(hass):
-    """When a call handler cancels, result_future should resolve to None."""
-    DecoratorManager.hass = hass
-    manager = FunctionDecoratorManager(DummyAstCtx(), DummyEvalFuncVar())
-    manager.add(make_cancel_call_handler())
-    future: asyncio.Future = hass.loop.create_future()
-
-    await call_function_manager(
-        manager,
-        make_dispatch_data(
-            {"arg1": 1},
-            call_ast_ctx=DummyCallAstCtx(result="unused"),
-            hass_context=Context(id="call-parent"),
-            result_future=future,
-        ),
-    )
-
-    assert future.done()
-    assert future.result() is None
-
-
-@pytest.mark.asyncio
-async def test_function_decorator_manager_result_future_exception(hass):
-    """When the decorated function raises, result_future should resolve to None."""
+async def test_function_decorator_manager_exception_calls_result_handlers(hass):
+    """When the decorated function raises, result handlers should be notified with None."""
     DecoratorManager.hass = hass
     ast_ctx = DummyAstCtx()
     manager = FunctionDecoratorManager(ast_ctx, DummyEvalFuncVar())
+    result_handler = make_recording_result_handler()
+    manager.add(result_handler)
     call_ast_ctx = DummyCallAstCtx(exc=RuntimeError("boom"))
-    future: asyncio.Future = hass.loop.create_future()
 
     with patch.object(Function, "store_hass_context"):
         await call_function_manager(
@@ -668,12 +620,10 @@ async def test_function_decorator_manager_result_future_exception(hass):
                 {"arg1": 1},
                 call_ast_ctx=call_ast_ctx,
                 hass_context=Context(id="call-parent"),
-                result_future=future,
             ),
         )
 
-    assert future.done()
-    assert future.result() is None
+    assert result_handler.results == [None]
     assert len(ast_ctx.logged_exceptions) == 1