support new error handling

Author: dmamelin

custom_components/pyscript/decorator.py

@@ -97,7 +97,7 @@ async def get_decorator_by_expr(cls, ast_ctx: AstEval, dec_expr: ast.expr) -> De
                 args = []
                 kwargs = {}
 
-            decorator = know_decorator(args, kwargs, dec_expr.lineno, dec_expr.col_offset)
+            decorator = know_decorator(args, kwargs)
             return decorator
 
         return None
@@ -136,7 +136,7 @@ async def wait_until(cls, ast_ctx: AstEval, *_arg: Any, **kwargs: Any) -> Any:
                 if key in kwargs:
                     dec_kwargs[key] = kwargs[key]
                     found_args.add(key)
-            dec = dec_class(dec_args, dec_kwargs, ast_ctx.lineno, ast_ctx.col_offset)
+            dec = dec_class(dec_args, dec_kwargs)
             dm.add(dec)
 
         unknown_args = set(kwargs.keys()).difference(found_args)
@@ -181,9 +181,7 @@ def __init__(self, ast_ctx: AstEval, **kwargs: dict[str, Any]) -> None:
         self.timeout_decorator = None
         if timeout := kwargs.get("timeout"):
             to_dec = DecoratorRegistry._decorators.get(DecoratorRegistry.prefix + "time_trigger")
-            self.timeout_decorator = to_dec(
-                [f"once(now + {timeout}s)"], {}, ast_ctx.lineno, ast_ctx.col_offset
-            )
+            self.timeout_decorator = to_dec([f"once(now + {timeout}s)"], {})
             self.add(self.timeout_decorator)
 
     async def dispatch(self, data: DispatchData) -> None:
@@ -196,11 +194,17 @@ async def dispatch(self, data: DispatchData) -> None:
         await self.stop()
         self._future.set_result(data)
 
+    async def handle_exception(self, exc: Exception) -> None:
+        """Propagate an evaluation exception to the waiting caller."""
+        if self._future.done():
+            _LOGGER.debug("task.wait_until future already completed: %s", self._future.exception())
+            return
+        await self.stop()
+        self._future.set_exception(exc)
+
     async def wait_until(self) -> dict[str, Any]:
         """Wait for dispatch and normalize the return payload."""
         data = await self._future
-        if data.exception is not None:
-            raise data.exception
         if data.trigger == self.timeout_decorator:
             ret = {"trigger_type": "timeout"}
         else:
@@ -253,17 +257,10 @@ async def _call(self, data: DispatchData) -> None:
         for result_handler_dec in result_handlers:
             await result_handler_dec.handle_call_result(data, result)
 
-        if data.call_ast_ctx.get_exception_obj():
-            data.call_ast_ctx.get_logger().error(data.call_ast_ctx.get_exception_long())
-
     async def dispatch(self, data: DispatchData) -> None:
         """Handle a trigger dispatch: run guards, create a context, and invoke the function."""
         _LOGGER.debug("Dispatching for %s: %s", self.name, data)
 
-        if data.exception:
-            self.logger.error(data.exception_text)
-            return
-
         decorators = self.get_decorators(TriggerHandlerDecorator)
         for dec in decorators:
             if await dec.handle_dispatch(data) is False:

custom_components/pyscript/decorator_abc.py

@@ -46,10 +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)
 
-    # Normally shouldn't be used.
-    exception: Exception | None = field(default=None, kw_only=True)
-    exception_text: str | None = field(default=None, kw_only=True)
-
 
 class Decorator(ABC):
     """Generic decorator abstraction."""
@@ -70,15 +66,10 @@ class Decorator(ABC):
     kwargs: dict[str, Any]
 
     @final
-    def __init__(
-        self, raw_args: list[Any], raw_kwargs: dict[str, Any], lineno: int, col_offset: int
-    ) -> None:
+    def __init__(self, raw_args: list[Any], raw_kwargs: dict[str, Any]) -> None:
         """Initialize the decorator definition."""
-
         self.raw_args = raw_args
         self.raw_kwargs = raw_kwargs
-        self.lineno = lineno
-        self.col_offset = col_offset
 
     async def validate(self) -> None:
         """Validate the arguments."""
@@ -106,12 +97,10 @@ async def validate(self) -> None:
             )
             raise type_error from err
 
-    @abstractmethod
-    async def start(self):
+    async def start(self):  # noqa: B027
         """Start the decorator."""
 
-    @abstractmethod
-    async def stop(self):
+    async def stop(self):  # noqa: B027
         """Stop the decorator."""
 
     def __repr__(self):
@@ -136,9 +125,6 @@ def __init__(self, ast_ctx: AstEval, name: str) -> None:
         self.func_name = name.split(".")[-1]
         self.logger = ast_ctx.get_logger()
 
-        self.lineno = ast_ctx.lineno
-        self.col_offset = ast_ctx.col_offset
-
         self.status: DecoratorManagerStatus = DecoratorManagerStatus.INIT
         self.startup_time = None
         self._decorators: list[Decorator] = []
@@ -167,19 +153,14 @@ def get_decorators[DT](self, decorator_type: type[DT] | None = None) -> list[DT]
 
     async def validate(self) -> None:
         """Validate all decorators."""
-        lineno, col_offset = self.ast_ctx.lineno, self.ast_ctx.col_offset
         try:
             for decorator in self._decorators:
-                self.ast_ctx.lineno, self.ast_ctx.col_offset = decorator.lineno, decorator.col_offset
                 _LOGGER.debug("Validating decorator: %s", decorator)
-                self.lineno, self.col_offset = decorator.lineno, decorator.col_offset
                 await decorator.validate()
         except Exception:
             self.update_status(DecoratorManagerStatus.INVALID)
             raise
 
-        self.ast_ctx.lineno, self.ast_ctx.col_offset = lineno, col_offset
-
         if len(self._decorators) == 0:
             self.update_status(DecoratorManagerStatus.NO_DECORATORS)
         else:
@@ -224,6 +205,10 @@ async def stop(self):
 
         self.update_status(DecoratorManagerStatus.STOPPED)
 
+    async def handle_exception(self, exc: Exception) -> None:
+        """Handle a decorator exception."""
+        self.ast_ctx.log_exception(exc)
+
     @abstractmethod
     async def dispatch(self, data: DispatchData) -> None:
         """Dispatch a trigger call."""

custom_components/pyscript/decorators/base.py

@@ -7,7 +7,7 @@
 import voluptuous as vol
 
 from ..decorator import FunctionDecoratorManager
-from ..decorator_abc import Decorator, DispatchData
+from ..decorator_abc import Decorator
 from ..eval import AstEval, Function
 
 _LOGGER = logging.getLogger(__name__)
@@ -43,9 +43,6 @@ def create_expression(self, expression: str) -> None:
         )
         Function.install_ast_funcs(self._ast_expression)
         self._ast_expression.parse(expression, mode="eval")
-        exc = self._ast_expression.get_exception_obj()
-        if exc is not None:
-            raise exc
 
     def has_expression(self) -> bool:
         """Return True if expression was created."""
@@ -55,9 +52,8 @@ async def check_expression_vars(self, state_vars: dict[str, Any]) -> bool:
         """Evaluate expression and dispatch an exception event via manager on failure."""
         if not self.has_expression():
             raise AttributeError(f"{self} has no expression defined")
-        ret = await self._ast_expression.eval(state_vars)
-        if exception := self._ast_expression.get_exception_obj():
-            exception_text = self._ast_expression.get_exception_long()
-            await self.dm.dispatch(DispatchData({}, exception=exception, exception_text=exception_text))
+        try:
+            return await self._ast_expression.eval(state_vars)
+        except Exception as exc:
+            await self.dm.handle_exception(exc)
             return False
-        return ret

custom_components/pyscript/decorators/service.py

@@ -74,7 +74,7 @@ async def validate(self) -> None:
             try:
                 desc = desc[4:].lstrip(" \n\r")
                 file_desc = io.StringIO(desc)
-                self.description = yaml.safe_load(file_desc) or OrderedDict()
+                self.description = yaml.load(file_desc, Loader=yaml.BaseLoader) or OrderedDict()  # noqa: S506
                 file_desc.close()
             except Exception as exc:
                 self.dm.logger.error(
@@ -106,13 +106,9 @@ async def _service_callback(self, call: ServiceCall) -> None:
         async def do_service_call(func, ast_ctx, data):
             try:
                 _LOGGER.debug("Service call start: %s", func.name)
-                retval = await func.call(ast_ctx, **data)
-                _LOGGER.debug("Service call done: %s", ast_ctx.get_exception_long())
-                if ast_ctx.get_exception_obj():
-                    ast_ctx.get_logger().error(ast_ctx.get_exception_long())
-                return retval
+                return await func.call(ast_ctx, **data)
             except Exception as exc:
-                _LOGGER.exception(exc)
+                await self.dm.handle_exception(exc)
                 return None
 
         task = Function.create_task(do_service_call(self.dm.eval_func, ast_ctx, func_args))

custom_components/pyscript/decorators/state.py

@@ -316,6 +316,6 @@ async def start(self) -> None:
     async def stop(self):
         """Stop the trigger."""
         await super().stop()
-        if hasattr(self, "cycle_task"):
+        if self.cycle_task is not None:
             self.cycle_task.cancel()
         State.notify_del(self.state_trig_ident, self.notify_q)

custom_components/pyscript/decorators/timing.py

@@ -144,7 +144,7 @@ async def _cycle(self):
 
     async def stop(self):
         """Stop the trigger."""
-        if hasattr(self, "_cycle_task"):
+        if self._cycle_task is not None:
             self._cycle_task.cancel()
         if self.run_on_shutdown:
             await self.dispatch(DispatchData({"trigger_type": "time", "trigger_time": "shutdown"}))

custom_components/pyscript/global_ctx.py

@@ -88,7 +88,7 @@ async def create_decorator_manager(
                 else:
                     self.dms_delay_start.add(dm)
         except Exception as exc:
-            _LOGGER.error(ast_ctx.format_exc(exc, dm.lineno, dm.col_offset))
+            ast_ctx.log_exception(exc)
 
     def trigger_unregister(self, func: EvalFunc) -> None:
         """Unregister a trigger function."""