Remove ability to trap exceptions from callbacks

At most, such exceptions will now be logged.

Author: jmattsson

src/powersensor_local/__init__.py

@@ -51,7 +51,7 @@
     'Events',
     'Message',
 ]
-__version__ = "2.4.0rc2"
+__version__ = "2.4.0rc3"
 from .devices import PowersensorDevices, PowersensorLegacyDevices
 from .legacy_discovery import LegacyDiscovery
 from .plug_api import PlugApi

src/powersensor_local/async_event_emitter.py

@@ -31,23 +31,13 @@ async def emit(self, event_name: str, *args: Any) -> None:
         """Emits an event to all registered listeners for that event type.
         Additional arguments may be supplied with event as appropriate. Each
         event handler is awaited before delivering the event to the next.
-        If an event handler raises an exception, this is funneled through
-        to an 'exception' event being emitted. If no 'exception' listener
-        is registered, or an exception handler callback raises an exception,
-        the exception is logged (if a logger was provided), and discarded."""
+        If an event handler raises an exception it is logged (if a logger was
+        provided), and discarded."""
         if self._listeners.get(event_name) is None:
             return
         for callback in self._listeners[event_name]:
             try:
                 await callback(event_name, *args)
             except Exception as e:
-              if 'exception' not in self._listeners:
                 if self._logger is not None:
-                  self._logger.exception(f"Discarding unhandled exception: {e}")
-              else:
-                for handler in self._listeners['exception']:
-                  try:
-                    await handler('exception', e)
-                  except Exception as e2:
-                    if self._logger is not None:
-                      self._logger.exception(f"Exception handling callback raised an exception itself, discarding it: {e2}")
+                    self._logger.exception(f"Logic error: exception escaped from callback: {e}")

src/powersensor_local/devices.py

@@ -21,7 +21,6 @@
     'average_power',
     'average_power_components',
     'battery_level',
-    'exception',
     'now_relaying_for',
     'radio_signal_quality',
     'summation_energy',
@@ -73,7 +72,7 @@ class _PowersensorDevicesBase:
     ``event`` field.  Known measurement events include:
 
     ``average_flow``, ``average_power``, ``average_power_components``,
-    ``battery_level``, ``exception``, ``now_relaying_for``,
+    ``battery_level``, ``now_relaying_for``,
     ``radio_signal_quality``, ``summation_energy``, ``summation_volume``.
 
     When ``relay_now_relaying_for=True`` the raw ``now_relaying_for`` wire
@@ -187,7 +186,7 @@ async def _plug_discovered(self, mac: str, ip: str, port: int) -> None:
             await self._remove_device(mac)
 
         await self._add_device(mac, 'plug')
-        api = PlugApi(mac, ip, port)
+        api = PlugApi(mac, ip, port, 'udp', self._logger)
         self._plug_apis[mac] = api
         for event in _KNOWN_PLUG_EVENTS:
             api.subscribe(event, self._reemit)

src/powersensor_local/plug_api.py

@@ -1,6 +1,8 @@
 """Interface abstraction for Powersensor plugs."""
 import sys
 
+from logging import Logger
+
 from .async_event_emitter import AsyncEventEmitter
 from .plug_listener_tcp import PlugListenerTcp
 from .plug_listener_udp import PlugListenerUdp
@@ -17,7 +19,7 @@ class PlugApi(AsyncEventEmitter):
     documented in xlatemsg.translate_raw_message.
     """
 
-    def __init__(self, mac: str, ip: str, port: int = 49476, proto: str = 'udp'):
+    def __init__(self, mac: str, ip: str, port: int = 49476, proto: str = 'udp', logger: Logger | None = None):
         """Create a :class:`PlugApi` instance for a single plug.
 
         Parameters
@@ -32,13 +34,15 @@ def __init__(self, mac: str, ip: str, port: int = 49476, proto: str = 'udp'):
             Protocol used for communication.  ``'udp'`` selects :class:`PlugListenerUdp`,
             while ``'tcp'`` selects :class:`PlugListenerTcp`.  Any other value raises a
             :class:`ValueError`.
+        logger : Logger, optional
+            If provided, enables the logging of escaped exceptions from callbacks.
 
         Raises
         ------
         ValueError
             If *proto* is not ``'udp'`` or ``'tcp'``.
         """
-        super().__init__()
+        super().__init__(logger)
         self._mac: str = mac
         self._listener: PlugListenerUdp | PlugListenerTcp
         if proto == 'udp':
@@ -48,7 +52,6 @@ def __init__(self, mac: str, ip: str, port: int = 49476, proto: str = 'udp'):
         else:
             raise ValueError(f'Unsupported proto: {proto}')
         self._listener.subscribe('message', self._on_message)
-        self._listener.subscribe('exception', self._on_exception)
         self._seen: set[str] = set()
 
     def connect(self) -> None:
@@ -93,10 +96,6 @@ async def _on_message(self, _: str, message: Message) -> None:
         for name, ev in evs.items():
             await self.emit(name, ev)
 
-    async def _on_exception(self, _: str, e: Exception) -> None:
-        """Propagates exceptions from the plug listener."""
-        await self.emit('exception', e)
-
     @property
     def ip_address(self) -> str:
         """

src/powersensor_local/plugevents.py

@@ -3,6 +3,7 @@
 """Utility script for accessing the plug api from a single network-local
 Powersensor device. Intended for advanced debugging use only."""
 
+import logging
 import sys
 from pathlib import Path
 
@@ -15,6 +16,8 @@
 from powersensor_local.abstract_event_handler import AbstractEventHandler
 from powersensor_local.xlatemsg import Message
 
+LOGGER = logging.getLogger(__name__)
+
 async def print_event_and_message(event: str, message: Message) -> None:
     """Callback for printing event data."""
     print(event, message)
@@ -37,9 +40,11 @@ async def main(self) -> None:
         # Signal handler for Ctrl+C
         self.register_sigint_handler()
 
-        plug = PlugApi(sys.argv[1], sys.argv[2], int(*sys.argv[3:3]))
+        port = int(*sys.argv[3:3])
+        if port == 0:
+            port = 49476
+        plug = PlugApi(sys.argv[1], sys.argv[2], port, 'udp', LOGGER)
         known_evs = [
-            'exception',
             'average_flow',
             'average_power',
             'average_power_components',

src/powersensor_local/rawplug.py

@@ -59,7 +59,6 @@ async def main(self) -> None:
         else:
             print('Unsupported protocol:', self._protocol)
             sys.exit(1)
-        self.plug.subscribe('exception', print_message_ignore_event)
         self.plug.subscribe('message', print_message_ignore_event)
         self.plug.subscribe('connecting', print_event)
         self.plug.subscribe('connecting', print_event)

tests/test_async_event_emitter.py

@@ -71,54 +71,4 @@ async def test_exception_unhandled() -> None:
   mock.side_effect = KeyError('oops')
   await emitter.emit('e')
   mock.assert_called_once()
-  logger.exception.assert_called_once_with("Discarding unhandled exception: 'oops'")
-
-
-@pytest.mark.asyncio
-async def test_exception_handler(emitter: AsyncEventEmitter) -> None:
-  mock = AsyncMock()
-  emitter.subscribe('e', mock)
-  e = KeyError('oops')
-  mock.side_effect = e
-  mock_exc = AsyncMock()
-  emitter.subscribe('exception', mock_exc)
-  await emitter.emit('e')
-  mock.assert_called_once()
-  mock_exc.assert_called_once_with('exception', e)
-
-
-@pytest.mark.asyncio
-async def test_exception_handler_exception() -> None:
-  logger = MagicMock()
-  emitter = AsyncEventEmitter(logger)
-  mock = AsyncMock()
-  emitter.subscribe('e', mock)
-  mock.side_effect = KeyError('oops')
-  mock_exc = AsyncMock()
-  emitter.subscribe('exception', mock_exc)
-  mock_exc.side_effect = ValueError('doh')
-  await emitter.emit('e')
-  mock.assert_called_once()
-  mock_exc.assert_called_once()
-  logger.exception.assert_called_once_with("Exception handling callback raised an exception itself, discarding it: doh")
-
-
-@pytest.mark.asyncio
-async def test_multiple_exception_handlers() -> None:
-  logger = MagicMock()
-  emitter = AsyncEventEmitter(logger)
-  trigger = AsyncMock()
-  e = ValueError('overflow')
-  trigger.side_effect = e
-  emitter.subscribe('e', trigger)
-  handlers = [ AsyncMock() for _ in range(5) ]
-  for handler in handlers:
-    emitter.subscribe('exception', handler)
-  bad_handlers = handlers[1::2] # pick every other
-  for handler in bad_handlers:
-    handler.side_effect = e
-  await emitter.emit('e')
-  trigger.assert_called_once()
-  for handler in handlers:
-    handler.assert_called_once()
-  assert(logger.exception.call_count == len(bad_handlers))
+  logger.exception.assert_called_once_with("Logic error: exception escaped from callback: 'oops'")