Disable config polling

Make config parameters only update once on startup
Update put to handle response and trigger the returned parameters
to be updated.
Add update loop to request specific parameters that need updating

Author: GDYendell

src/eiger_fastcs/eiger_controller.py

@@ -1,13 +1,13 @@
 import asyncio
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Coroutine, Type
 
 from attr import Attribute
 from fastcs.attributes import AttrR, AttrRW, AttrW
 from fastcs.connections import HTTPConnection, IPConnectionSettings
 from fastcs.controller import Controller
 from fastcs.datatypes import Bool, Float, Int, String
-from fastcs.wrappers import command
+from fastcs.wrappers import command, scan
 
 
 @dataclass
@@ -22,19 +22,11 @@ class EigerHandler:
     name: str
     update_period: float = 0.2
 
-    async def put(
-        self,
-        controller: "EigerController",
-        attr: AttrW,
-        value: Any,
-    ) -> None:
-        await controller.connection.put(self.name, value)
-
-    async def update(
-        self,
-        controller: "EigerController",
-        attr: AttrR,
-    ) -> None:
+    async def put(self, controller: "EigerController", _: AttrW, value: Any) -> None:
+        parameters_to_update = await controller.connection.put(self.name, value)
+        await controller.queue_update(parameters_to_update)
+
+    async def update(self, controller: "EigerController", attr: AttrR) -> None:
         try:
             # TODO: Async sleep?
             response = await controller.connection.get(self.name)
@@ -43,6 +35,21 @@ async def update(
             print(f"update loop failed:{e}")
 
 
+class EigerConfigHandler(EigerHandler):
+    """Handler for config parameters that are polled once on startup."""
+
+    first_poll_complete: bool = False
+
+    async def update(self, controller: "EigerController", attr: AttrR) -> None:
+        # Only poll once on startup
+        if not self.first_poll_complete:
+            await super().update(controller, attr)
+            self.first_poll_complete = True
+
+    async def config_update(self, controller: "EigerController", attr: AttrR) -> None:
+        await super().update(controller, attr)
+
+
 @dataclass
 class LogicHandler:
     """
@@ -54,15 +61,16 @@ class LogicHandler:
 
     name: str
 
-    async def put(
-        self,
-        controller: "EigerController",
-        attr: AttrW,
-        value: Any,
-    ) -> None:
+    async def put(self, _: "EigerController", attr: AttrW, value: Any) -> None:
         await attr.set(value)
 
 
+EIGER_HANDLERS: dict[str, Type[EigerHandler]] = {
+    "status": EigerHandler,
+    "config": EigerConfigHandler,
+}
+
+
 class EigerController(Controller):
     """
     Controller Class for Eiger Detector
@@ -75,11 +83,16 @@ class EigerController(Controller):
         Bool(),
         handler=LogicHandler("manual trigger"),
     )
+    stale_parameters = AttrR(Bool())
 
     def __init__(self, settings: IPConnectionSettings) -> None:
         super().__init__()
         self._ip_settings = settings
 
+        # Parameter update logic
+        self._parameter_updates: set[str] = set()
+        self._parameter_update_lock = asyncio.Lock()
+
         asyncio.run(self.initialise())
 
     async def connect(self) -> None:
@@ -162,14 +175,14 @@ async def initialise(self) -> None:
                         case "r":
                             attributes[name] = AttrR(
                                 datatype,
-                                handler=EigerHandler(
+                                handler=EIGER_HANDLERS[mode](
                                     f"{subsystem}/api/1.8.0/{mode}/{parameter_name}"
                                 ),
                             )
                         case "rw":
                             attributes[name] = AttrRW(
                                 datatype,
-                                handler=EigerHandler(
+                                handler=EIGER_HANDLERS[mode](
                                     f"{subsystem}/api/1.8.0/{mode}/{parameter_name}"
                                 ),
                             )
@@ -250,3 +263,44 @@ async def start_acquisition(self):
             for i in range(self.ntrigger._value):
                 print(f"Acquisition number: {i+1}")
                 await self.trigger()
+
+    async def queue_update(self, parameters: list[str]):
+        """Add the given parameters to the list of parameters to update.
+
+        Args:
+            parameters: Parameters to be updated
+
+        """
+        async with self._parameter_update_lock:
+            for parameter in parameters:
+                self._parameter_updates.add(parameter)
+
+            await self.stale_parameters.set(True)
+
+    @scan(0.1)
+    async def update(self):
+        """Periodically update all stale parameters."""
+        if not self._parameter_updates:
+            if self.stale_parameters.get():
+                await self.stale_parameters.set(False)
+
+            return
+
+        # Take a copy of the current parameters and clear. Parameters may be repopulated
+        # during this call and need to be updated again immediately.
+        async with self._parameter_update_lock:
+            parameters = self._parameter_updates.copy()
+            self._parameter_updates.clear()
+
+        # Release lock while fetching parameters - this may be slow
+        parameter_updates: list[Coroutine] = []
+        for parameter in parameters:
+            match getattr(self, parameter):
+                # TODO: mypy doesn't understand AttrR as a type for some reason:
+                # `error: Expected type in class pattern; found "Any"  [misc]`
+                case AttrR(updater=EigerConfigHandler() as updater) as attr:  # type: ignore [misc]
+                    parameter_updates.append(updater.config_update(self, attr))
+                case _:
+                    print(f"Failed to handle update for {parameter}")
+
+        await asyncio.gather(*parameter_updates)