Eiger-Device (Exts logic)

.vscode/launch.json

@@ -18,6 +18,13 @@
             "module":"tickit",
             "args": ["all", "examples/configs/sunk-tcp.yaml"]
         },
+        {
+            "name":"Eiger",
+            "type":"python",
+            "request":"launch",
+            "module":"tickit",
+            "args": ["all", "examples/configs/eiger.yaml"]
+        },
         {
             "name":"Nested",
             "type":"python",

tests/adapters/test_httpadapter.py

@@ -27,7 +27,7 @@ class MockAdapter(HTTPAdapter):
 
     device: Device
 
-    @HTTPEndpoint.get("/mock_endpoint")
+    @HTTPEndpoint.get("/mock_endpoint", interrupt=True)
     async def mock_endpoint(request: web.Request) -> web.Response:
         return web.Response(text="test")
 
@@ -63,9 +63,12 @@ async def test_http_adapter_run_forever_method(
 
 
 @pytest.mark.asyncio
-async def test_http_adapter_endpoints():
+async def test_http_adapter_endpoints(
+    mock_device: Device, mock_raise_interrupt: Mock, patch_asyncio_event_wait: Mock
+):
 
-    adapter = MockAdapter()
+    adapter = MockAdapter(port=8081)
+    await adapter.run_forever(mock_device, mock_raise_interrupt)
 
     resp = await list(adapter.endpoints())[0].handler()
 

tests/adapters/test_zmqadapter.py

@@ -35,8 +35,7 @@ async def _process_message_queue():
 @pytest.fixture
 def zeromq_adapter() -> ZeroMQAdapter:
     zmq_adapter = ZeroMQAdapter()
-    zmq_adapter._dealer = AsyncMock()
-    zmq_adapter._router = AsyncMock()
+    zmq_adapter._socket = AsyncMock()
     zmq_adapter._message_queue = Mock(asyncio.Queue)
     return zmq_adapter
 
@@ -49,8 +48,7 @@ def test_zeromq_adapter_constructor():
 async def test_zeromq_adapter_start_stream(zeromq_adapter):
     await zeromq_adapter.start_stream()
 
-    assert isinstance(zeromq_adapter._router, aiozmq.stream.ZmqStream)
-    assert isinstance(zeromq_adapter._dealer, aiozmq.stream.ZmqStream)
+    assert isinstance(zeromq_adapter._socket, aiozmq.stream.ZmqStream)
 
     await zeromq_adapter.close_stream()
 
@@ -62,8 +60,7 @@ async def test_zeromq_adapter_close_stream(zeromq_adapter):
     await zeromq_adapter.close_stream()
     await asyncio.sleep(0.1)
 
-    assert None is zeromq_adapter._router._transport
-    assert None is zeromq_adapter._dealer._transport
+    assert None is zeromq_adapter._socket._transport
 
 
 @pytest.mark.asyncio
@@ -80,7 +77,7 @@ async def test_zeromq_adapter_send_message(zeromq_adapter):
     zeromq_adapter.send_message(mock_message)
     task = asyncio.current_task()
     asyncio.gather(task)
-    zeromq_adapter._message_queue.put.assert_called_once()
+    zeromq_adapter._message_queue.put_nowait.assert_called_once()
 
 
 @pytest.mark.asyncio
@@ -118,24 +115,19 @@ async def test_zeromq_adapter_process_message_queue(zeromq_adapter):
 @pytest.mark.asyncio
 async def test_zeromq_adapter_process_message(zeromq_adapter):
 
-    mock_message = "test"
-
-    zeromq_adapter._dealer.read.return_value = ("Data", "test")
-    zeromq_adapter._router.read.return_value = ("Data", "test")
+    mock_message = [b"test"]
 
     await zeromq_adapter._process_message(mock_message)
 
-    zeromq_adapter._dealer.read.assert_awaited_once()
-    zeromq_adapter._router.read.assert_awaited_once()
+    zeromq_adapter._socket.write.assert_called_once()
 
 
 @pytest.mark.asyncio
 async def test_zeromq_adapter_process_message_no_message(zeromq_adapter, caplog):
 
     mock_message = None
 
-    zeromq_adapter._dealer.read.return_value = ("Data", None)
-    zeromq_adapter._router.read.return_value = ("Data", None)
+    zeromq_adapter._socket.read.return_value = ("Data", None)
 
     with caplog.at_level(logging.DEBUG):
         await zeromq_adapter._process_message(mock_message)

tests/devices/eiger/test_eiger.py

@@ -1,5 +1,7 @@
 import pytest
 
+from tickit.core.device import DeviceUpdate
+from tickit.core.typedefs import SimTime
 from tickit.devices.eiger.eiger import EigerDevice
 from tickit.devices.eiger.eiger_status import State
 
@@ -22,6 +24,8 @@ async def test_eiger_initialize(eiger: EigerDevice):
 
 @pytest.mark.asyncio
 async def test_eiger_arm(eiger: EigerDevice):
+    eiger.stream_config.header_detail = "all"
+
     await eiger.arm()
 
     assert State.READY.value == eiger.get_state()["value"]
@@ -97,3 +101,42 @@ def test_eiger_set_state(eiger: EigerDevice):
     eiger._set_state(State.IDLE)
 
     assert State.IDLE.value == eiger.get_state()["value"]
+
+
+def test_eiger_update_not_aquiring(eiger: EigerDevice):
+
+    eiger._set_state(State.IDLE)
+
+    time = None
+    device_input = {"bleep", "bloop"}
+
+    update: DeviceUpdate = eiger.update(time, device_input)
+    assert update.outputs == {}
+
+
+def test_eiger_update_aquiring(eiger: EigerDevice):
+
+    eiger._set_state(State.ACQUIRE)
+
+    eiger._num_frames_left = 1
+
+    time = SimTime(int(1e8))
+    device_input = {"bleep", "bloop"}
+
+    update: DeviceUpdate = eiger.update(time, device_input)
+    assert update.outputs == {}
+
+
+def test_eiger_update_aquiring_no_frames_left(eiger: EigerDevice):
+
+    eiger._set_state(State.ACQUIRE)
+
+    eiger._num_frames_left = 0
+
+    time = None
+    device_input = {"bleep", "bloop"}
+
+    update: DeviceUpdate = eiger.update(time, device_input)
+
+    assert eiger.get_state()["value"] == State.IDLE.value
+    assert update.outputs == {}

tests/devices/eiger/test_eiger_adapters.py

@@ -65,10 +65,10 @@ def mock_request():
 async def test_eiger_system(tickit_task):
 
     commands = {
-        "initialize": {"sequence_id": 1},
-        "disarm": {"sequence_id": 3},
-        "cancel": {"sequence_id": 5},
-        "abort": {"sequence_id": 6},
+        "initialize": {"sequence id": 1},
+        "disarm": {"sequence id": 3},
+        "cancel": {"sequence id": 5},
+        "abort": {"sequence id": 6},
     }
 
     url = "http://0.0.0.0:8081/detector/api/1.8.0/"
@@ -90,7 +90,7 @@ async def get_status(status, expected):
         async with session.put(
             url + "config/element", headers=headers, data=data
         ) as resp:
-            assert json.loads(str(await resp.text())) == {"sequence_id": 7}
+            assert json.loads(str(await resp.text())) == []
 
         # Test each command
         for key, value in commands.items():
@@ -117,7 +117,7 @@ async def get_status(status, expected):
         async with session.put(
             url + "config/doesnt_exist", headers=headers, data=data
         ) as resp:
-            assert json.loads(str(await resp.text())) == {"sequence_id": 9}
+            assert json.loads(str(await resp.text())) == []
 
         async with session.get(url + "config/element") as resp:
             assert json.loads(str(await resp.text()))["value"] == "Co"
@@ -126,31 +126,77 @@ async def get_status(status, expected):
         async with session.put(
             url + "config/element", headers=headers, data=data
         ) as resp:
-            assert json.loads(str(await resp.text())) == {"sequence_id": 8}
+            assert json.loads(str(await resp.text())) == ["element"]
 
         async with session.get(url + "config/photon_energy") as resp:
-            assert json.loads(str(await resp.text()))["value"] == 54.3
+            assert 54.3 == json.loads(str(await resp.text()))["value"]
 
         async with session.get(filewriter_url + "config/mode") as resp:
             assert "enabled" == json.loads(str(await resp.text()))["value"]
 
+        data = '{"value": "enabled"}'
+        async with session.put(
+            filewriter_url + "config/mode", headers=headers, data=data
+        ) as resp:
+            assert ["mode"] == json.loads(str(await resp.text()))
+
+        data = '{"value": "test"}'
+        async with session.put(
+            filewriter_url + "config/test", headers=headers, data=data
+        ) as resp:
+            assert [] == json.loads(str(await resp.text()))
+
         async with session.get(filewriter_url + "status/state") as resp:
             assert "ready" == json.loads(str(await resp.text()))["value"]
 
         async with session.get(monitor_url + "config/mode") as resp:
             assert "enabled" == json.loads(str(await resp.text()))["value"]
 
+        data = '{"value": "enabled"}'
+        async with session.put(
+            monitor_url + "config/mode", headers=headers, data=data
+        ) as resp:
+            assert ["mode"] == json.loads(str(await resp.text()))
+
+        data = '{"value": "test"}'
+        async with session.put(
+            monitor_url + "config/test", headers=headers, data=data
+        ) as resp:
+            assert [] == json.loads(str(await resp.text()))
+
         async with session.get(monitor_url + "status/error") as resp:
             assert [] == json.loads(str(await resp.text()))["value"]
 
         async with session.get(stream_url + "config/mode") as resp:
             assert "enabled" == json.loads(str(await resp.text()))["value"]
 
+        data = '{"value": "enabled"}'
+        async with session.put(
+            stream_url + "config/mode", headers=headers, data=data
+        ) as resp:
+            assert ["mode"] == json.loads(str(await resp.text()))
+
+        data = '{"value": "test"}'
+        async with session.put(
+            stream_url + "config/test", headers=headers, data=data
+        ) as resp:
+            assert [] == json.loads(str(await resp.text()))
+
+        data = '{"value": "ints"}'
+        async with session.put(
+            url + "config/trigger_mode", headers=headers, data=data
+        ) as resp:
+            assert ["trigger_mode"] == json.loads(str(await resp.text()))
+
         async with session.get(stream_url + "status/state") as resp:
             assert "ready" == json.loads(str(await resp.text()))["value"]
 
+        assert get_status(status="state", expected="idle")
+
         async with session.put(url + "command/arm") as resp:
-            assert {"sequence_id": 2} == json.loads(str(await resp.text()))
+            assert {"sequence id": 2} == json.loads(str(await resp.text()))
+
+        assert get_status(status="state", expected="ready")
 
         async with session.put(url + "command/trigger") as resp:
-            assert {"sequence_id": 4} == json.loads(str(await resp.text()))
+            assert {"sequence id": 4} == json.loads(str(await resp.text()))

tests/devices/eiger/test_eiger_settings.py

@@ -29,3 +29,33 @@ def test_eiger_settings_set_element(eiger_settings):
 
     assert "Li" == eiger_settings.element
     assert KA_Energy["Li"].value == eiger_settings.photon_energy
+    assert (1240 / eiger_settings.photon_energy) / 10 == eiger_settings.wavelength
+    assert 0.5 * eiger_settings.photon_energy == eiger_settings.threshold_energy
+
+
+def test_eiger_settings_set_photon_energy(eiger_settings):
+    eiger_settings["photon_energy"] = 1000.0
+
+    assert 1000.0 == eiger_settings.photon_energy
+    assert "" == eiger_settings.element
+    assert (1240 / eiger_settings.photon_energy) / 10 == eiger_settings.wavelength
+    assert 0.5 * eiger_settings.photon_energy == eiger_settings.threshold_energy
+
+
+def test_eiger_settings_set_wavelength(eiger_settings):
+    eiger_settings["wavelength"] = 1.24
+
+    assert 1.24 == eiger_settings.wavelength
+    assert "" == eiger_settings.element
+    assert 1240 / (eiger_settings.wavelength * 10) == eiger_settings.photon_energy
+    assert 0.5 * eiger_settings.photon_energy == eiger_settings.threshold_energy
+
+
+def test_eiger_settings_set_count_time(eiger_settings):
+    eiger_settings["count_time"] = 0.2
+
+    assert 0.2 == eiger_settings.count_time
+    assert (
+        eiger_settings.count_time + eiger_settings.detector_readout_time
+        == eiger_settings.frame_time
+    )

tests/devices/eiger/test_eiger_status.py

@@ -15,4 +15,4 @@ def test_eiger_status_constructor():
 
 
 def test_eiger_status_getitem(eiger_status):
-    assert 24.5 == eiger_status["th0_temp"]
+    assert 24.5 == eiger_status["th0_temp"]["value"]

tickit/adapters/httpadapter.py

@@ -2,7 +2,7 @@
 import logging
 from dataclasses import dataclass
 from inspect import getmembers
-from typing import Iterable
+from typing import Callable, Iterable
 
 from aiohttp import web
 from aiohttp.web_routedef import RouteDef
@@ -64,4 +64,14 @@ def endpoints(self) -> Iterable[RouteDef]:
         for _, func in getmembers(self):
             endpoint: HTTPEndpoint = getattr(func, "__endpoint__", None)
             if endpoint is not None:
-                yield endpoint.define(func)
+                yield self._make_route_def(func, endpoint)
+
+    def _make_route_def(self, func: Callable, endpoint: HTTPEndpoint) -> RouteDef:
+        # Create wrapper around endpoint function that calls interrupt where necessary
+        async def wrapped_func(*args, **kwargs):
+            reply = await func(*args, **kwargs)
+            if endpoint.interrupt:
+                await self.raise_interrupt()
+            return reply
+
+        return endpoint.define(wrapped_func)