Dbus client report handler

Author: jfhbrook

crystalfontz/dbus/client/__init__.py

@@ -7,17 +7,22 @@
 from crystalfontz.dbus.config import StagedConfig
 from crystalfontz.dbus.domain import ConfigM
 from crystalfontz.dbus.interface import DBUS_NAME, DbusInterface
+from crystalfontz.dbus.report import DbusReportHandler
 
 
 class DbusClient(DbusInterface):
     """
     A DBus client for the Crystalfontz device.
     """
 
-    def __init__(self: Self, bus: Optional[SdBus] = None) -> None:
+    def __init__(
+        self: Self,
+        bus: Optional[SdBus] = None,
+        report_handler: Optional[DbusReportHandler] = None,
+    ) -> None:
         client = Mock(name="client", side_effect=NotImplementedError("client"))
         self.subscribe = Mock(name="client.subscribe")
-        super().__init__(client)
+        super().__init__(client, report_handler=report_handler)
 
         cast(Any, self)._proxify(DBUS_NAME, "/", bus=bus)
 

crystalfontz/dbus/client/cli.py

@@ -52,6 +52,7 @@
     VersionsM,
 )
 from crystalfontz.dbus.error import handle_dbus_error
+from crystalfontz.dbus.report import DbusClientCliReportHandler
 from crystalfontz.gpio import GpioDriveMode, GpioFunction
 from crystalfontz.lcd import LcdRegister
 from crystalfontz.temperature import (
@@ -203,7 +204,10 @@ async def load() -> None:
         elif user is None:
             select_system_bus()
 
-        client = DbusClient()
+        report_handler = DbusClientCliReportHandler()
+        report_handler.mode = output
+
+        client = DbusClient(report_handler=report_handler)
         ctx.obj = Obj(
             client=client,
             log_level=log_level,

crystalfontz/dbus/interface.py

@@ -83,8 +83,9 @@
     VersionsT,
 )
 from crystalfontz.dbus.domain.temperature import TemperatureDisplayItemT
+from crystalfontz.dbus.report import DbusInterfaceReportHandler
 from crystalfontz.error import ConnectionError
-from crystalfontz.report import KeyActivityReport, ReportHandler, TemperatureReport
+from crystalfontz.report import ReportHandler
 
 Ok = bool
 
@@ -93,25 +94,8 @@
 DBUS_NAME = "org.jfhbrook.crystalfontz"
 
 
-class DbusReportHandler(ReportHandler):
-    def __init__(self: Self) -> None:
-        self.iface: "Optional[DbusInterface]" = None
-
-    async def on_key_activity(self: Self, report: KeyActivityReport) -> None:
-        if not self.iface:
-            return
-
-        self.iface.key_activity_reports.emit(KeyActivityReportM.pack(report))
-
-    async def on_temperature(self: Self, report: TemperatureReport) -> None:
-        if not self.iface:
-            return
-
-        self.iface.temperature_reports.emit(TemperatureReportM.pack(report))
-
-
 async def load_client(
-    report_handler: Optional[DbusReportHandler], config_file: Optional[str]
+    report_handler: Optional[ReportHandler], config_file: Optional[str]
 ) -> Client:
     config: Config = Config.from_file(config_file)
 
@@ -130,17 +114,17 @@ class DbusInterface(  # type: ignore
     def __init__(
         self: Self,
         client: Client,
-        report_handler: Optional[DbusReportHandler] = None,
+        report_handler: Optional[ReportHandler] = None,
         config_file: Optional[str] = None,
     ) -> None:
         super().__init__()
         self._config: Config = Config.from_file(config_file)
         self.client: Client = client
         self._client_lock: asyncio.Lock = asyncio.Lock()
-        self._report_handler = report_handler
+        self.report_handler = report_handler
 
-        if self._report_handler:
-            self._report_handler.iface = self
+        if isinstance(self.report_handler, DbusInterfaceReportHandler):
+            self.report_handler.iface = self
 
     @dbus_property_async(ConfigM.t)
     def config(self: Self) -> ConfigT:

crystalfontz/dbus/report.py

@@ -0,0 +1,114 @@
+from abc import ABC
+import asyncio
+import json
+from typing import Any, Optional, Protocol, Self, TypeVar
+
+from crystalfontz.dbus.domain import (
+    KeyActivityReportM,
+    TemperatureReportM,
+)
+from crystalfontz.format import OutputMode
+from crystalfontz.report import (
+    KeyActivityReport,
+    ReportHandler,
+    TemperatureReport,
+)
+
+T = TypeVar("T")
+
+
+class DbusInterfaceProtocol(Protocol):
+    # These types are NOT DbusSignalAsync[T]. They're defined as such in the
+    # interface class, but are modified by metaclass. This gets pretty
+    # confusing for the type checker! So in this case, we cheese it.
+    key_activity_reports: Any
+    temperature_reports: Any
+
+
+class DbusReportHandler(ReportHandler, ABC):
+    def __init__(self: Self) -> None:
+        self.iface: Optional[DbusInterfaceProtocol] = None
+
+
+class DbusInterfaceReportHandler(DbusReportHandler):
+    """
+    A report handler which emits reports on a supplied interface.
+    """
+
+    def __init__(self: Self) -> None:
+        self.iface: Optional[DbusInterfaceProtocol] = None
+
+    async def on_key_activity(self: Self, report: KeyActivityReport) -> None:
+        if not self.iface:
+            return
+
+        self.iface.key_activity_reports.emit(KeyActivityReportM.pack(report))
+
+    async def on_temperature(self: Self, report: TemperatureReport) -> None:
+        if not self.iface:
+            return
+
+        self.iface.temperature_reports.emit(TemperatureReportM.pack(report))
+
+
+class DbusClientReportHandler(DbusReportHandler):
+    """
+    A report handler which listens to reports emitted by a dbus interface.
+    """
+
+    def __init__(self: Self) -> None:
+        super().__init__()
+
+        self._key_activity_task: Optional[asyncio.Task] = None
+        self._temperature_task: Optional[asyncio.Task] = None
+
+    async def _listen_key_activity(self: Self) -> None:
+        if self.iface:
+            async for report in self.iface.key_activity_reports:
+                await self.on_key_activity(KeyActivityReportM.unpack(report))
+
+    async def _listen_temperature(self: Self) -> None:
+        if self.iface:
+            async for report in self.iface.temperature_reports:
+                await self.on_temperature(TemperatureReportM.unpack(report))
+
+    async def listen(self: Self) -> None:
+        self._key_activity_task = asyncio.create_task(self._listen_key_activity())
+        self._temperature_task = asyncio.create_task(self._listen_temperature())
+
+    async def _wait(self: Self) -> None:
+        if self._key_activity_task:
+            try:
+                await self._key_activity_task
+            except asyncio.CancelledError:
+                pass
+
+        if self._temperature_task:
+            try:
+                await self._temperature_task
+            except asyncio.CancelledError:
+                pass
+
+    async def stop(self: Self) -> None:
+        if self._key_activity_task:
+            self._key_activity_task.cancel()
+        if self._temperature_task:
+            self._temperature_task.cancel()
+
+        await self._wait()
+
+
+class DbusClientCliReportHandler(DbusClientReportHandler):
+    mode: Optional[OutputMode] = None
+
+    async def on_key_activity(self: Self, report: KeyActivityReport) -> None:
+        if self.mode == "json":
+            print(json.dumps(report.as_dict()))
+        elif self.mode == "text":
+            print(repr(report))
+
+    async def on_temperature(self: Self, report: TemperatureReport) -> None:
+        if self.mode == "json":
+            print(json.dumps(report.as_dict()))
+        elif self.mode == "text":
+            print(repr(report))

crystalfontz/dbus/service/__init__.py

@@ -18,9 +18,9 @@
 from crystalfontz.dbus.interface import (
     DBUS_NAME,
     DbusInterface,
-    DbusReportHandler,
     load_client,
 )
+from crystalfontz.dbus.report import DbusInterfaceReportHandler
 
 logger = logging.getLogger(__name__)
 
@@ -31,7 +31,7 @@ async def service(config_file: Optional[str] = None) -> DbusInterface:
     """
 
     client = await load_client(
-        report_handler=DbusReportHandler(), config_file=config_file
+        report_handler=DbusInterfaceReportHandler(), config_file=config_file
     )
     iface = DbusInterface(client, config_file=config_file)