Macro: Provide a way to define abstract macro state machine

See merge request Karabo/Framework!5523

Author: dgoeries

src/pythonKarabo/karabo/middlelayer_api/macro.py

@@ -81,9 +81,9 @@ async def suppress_exception(coro):
         pass
 
 
-def _wrapslot(slot, name):
+def _wrapslot(slot, name, abstract_passive, abstract_active):
     if slot.allowedStates is None:
-        slot.allowedStates = {State.PASSIVE}
+        slot.allowedStates = {abstract_passive}
     themethod = slot.method
 
     # Note: No need to re-raise CancelledErrors, we got cancelled
@@ -94,7 +94,7 @@ def _wrapslot(slot, name):
         async def wrapper(device):
             device._last_action = current_task()
             device.currentSlot = name
-            device.state = State.ACTIVE
+            device.state = abstract_active
             try:
                 return (await themethod(device))
             except CancelledError:
@@ -104,13 +104,13 @@ async def wrapper(device):
                 loop.create_task(coro, instance=device)
             finally:
                 device.currentSlot = ""
-                device.state = State.PASSIVE
+                device.state = abstract_passive
     else:
         @wraps(themethod)
         def wrapper(device):
             device._last_action = get_event_loop()
             device.currentSlot = name
-            device.state = State.ACTIVE
+            device.state = abstract_active
             try:
                 return themethod(device)
             except CancelledError:
@@ -120,12 +120,16 @@ def wrapper(device):
                 loop.create_task(coro, instance=device)
             finally:
                 device.currentSlot = ""
-                device.state = State.PASSIVE
+                device.state = abstract_passive
 
     slot.method = wrapper
 
 
 class Macro(Device):
+
+    abstractPassiveState = State.PASSIVE
+    abstractActiveState = State.ACTIVE
+
     abstract = True
     subclasses = []
     _last_action = None
@@ -181,7 +185,9 @@ def register(cls, name, dict):
         for k, v in dict.items():
             # patch slots for macro state machine behavior
             if isinstance(v, Slot):
-                _wrapslot(v, k)
+                passive_state = cls.abstractPassiveState
+                active_state = cls.abstractActiveState
+                _wrapslot(v, k, passive_state, active_state)
         super().register(name, dict)
         # every macro cls is appended to the subclasses for the macro server
         # to instantiate
@@ -239,7 +245,7 @@ async def connect(key, remote):
                        if isinstance(v, RemoteDevice)))
         for h in holders:
             ensure_future(h)
-        self.state = State.PASSIVE
+        self.state = self.abstractPassiveState
 
     async def __holdDevice(self, d):
         """keep the connection to a remote device

src/pythonKarabo/karabo/middlelayer_api/tests/macro_test.py

@@ -148,6 +148,17 @@ async def asyncSleep(self):
         await sleep(1)
 
 
+class LocalAbstract(Macro):
+    abstractPassiveState = State.ON
+    abstractActiveState = State.MOVING
+
+    @Slot()
+    def start(self):
+        """Just sleep a bit for state change"""
+        sleep(0.1)
+
+
+
 class Tests(DeviceTest):
     @classmethod
     @contextmanager
@@ -638,5 +649,33 @@ async def test_async_slot_macro(self):
             self.assertEqual(d.state, State.PASSIVE)
 
 
+class AbstractMacroTest(DeviceTest):
+    @classmethod
+    @contextmanager
+    def lifetimeManager(cls):
+        cls.local = LocalAbstract(_deviceId_="local_abstract", project="test", module="test")
+        with cls.deviceManager(lead=cls.local):
+            yield
+
+    @async_tst
+    async def test_state_machine(self):
+        """test the execution of abstract macro with new state machine"""
+        with await getDevice("local_abstract") as d:
+            self.assertEqual(d.state, State.ON)
+
+            seen = False
+            async def show_active():
+                nonlocal d, seen
+                await waitUntil(lambda: d.state == State.MOVING)
+                seen = True
+
+            task = background(show_active())
+            # Give background a chance to post on loop!
+            await sleep(0.05)
+            await d.start()
+            await task
+            self.assertTrue(seen)
+
+
 if __name__ == "__main__":
     main()