Make api version configurable

[GDYendell]

To support older eiger detectors, users should be able to configure the driver to use api 1.6.0 in HTTP requests

Acceptance Criteria

• EigerController takes an optional api_version, default "1.8.0"
• CLI has an optional --api-version, default "1.8.0"
• All hardcoded usages of "1.8.0" are replaced by this config

[toqduj]

There are differences to be addressed. Running the commands

podman run --entrypoint bash --rm -it  -v ./opi/:/epics/opi --net=host ghcr.io/diamondlightsource/fastcs-eiger:latest
  find /venv/lib64/python3.11/site-packages/fastcs_eiger -type f -name "*.py" -exec sed -i 's/1\.8\.0/1\.6\.0/g' {} +
  fastcs-eiger ioc EIGER --odin-ip 127.0.0.1 --ip 172.17.1.2 --port 80

gives me:

​root@WS8665:/epics/opi# fastcs-eiger ioc EIGER --odin-ip 127.0.0.1 --ip 172.17.1.2 --port 80
[2026-02-06 09:03:56.892+0000 W] Removing parameters with invalid names                                           [fastcs_odin.util] parameters=['0/status/decoder/name']
[2026-02-06 09:03:56.892+0000 W] Removing parameters with invalid names                                           [fastcs_odin.util] parameters=['1/status/decoder/name']
[2026-02-06 09:03:56.893+0000 W] Removing parameters with invalid names                                           [fastcs_odin.util] parameters=['2/status/decoder/name']
[2026-02-06 09:03:56.893+0000 W] Removing parameters with invalid names                                           [fastcs_odin.util] parameters=['3/status/decoder/name']
[2026-02-06 09:03:56.895+0000 D] Validated hinted attribute                                                       [fastcs.controllers.base_controller] name=state, controller=EigerFanAdapterController(path=OD.EF, sub_controllers=None), attribute=AttrR(name=OD.EF.state, datatype=String, io_ref=ParameterTreeAttributeIORef(update_period=0.2, path='api/0.1/ef/0/status/state'))
╭──────────────────────────────────────── Traceback (most recent call last) ────────────────────────────────────────╮
│ /venv/lib/python3.11/site-packages/fastcs_eiger/__main__.py:79 in ioc                                             │
│                                                                                                                   │
│   76 │   │   ),                                                                                                   │
│   77 │   ]                                                                                                        │
│   78 │   launcher = FastCS(controller, transports)                                                                │
│ ❱ 79 │   launcher.run()                                                                                           │
│   80                                                                                                              │
│   81                                                                                                              │
│   82 # test with: python -m fastcs_eiger                                                                          │
│                                                                                                                   │
│ ╭─────────────────────────────────────── locals ────────────────────────────────────────╮                         │
│ │ controller = EigerOdinController(path=None, sub_controllers=['OD', 'detector'])       │                         │
│ │         ip = '172.17.1.2'                                                             │                         │
│ │   launcher = <fastcs.control_system.FastCS object at 0x750e031757d0>                  │                         │
│ │  log_level = <LogLevel.TRACE: 'TRACE'>                                                │                         │
│ │    odin_ip = '127.0.0.1'                                                              │                         │
│ │  odin_port = 8888                                                                     │                         │
│ │       port = 80                                                                       │                         │
│ │  pv_prefix = 'EIGER'                                                                  │                         │
│ │ transports = [<repr-error "'EpicsCATransport' object has no attribute '_pv_prefix'">] │                         │
│ │    ui_path = PosixPath('/epics/opi')                                                  │                         │
│ ╰───────────────────────────────────────────────────────────────────────────────────────╯                         │
│                                                                                                                   │
│ /venv/lib/python3.11/site-packages/fastcs/control_system.py:50 in run                                             │
│                                                                                                                   │
│    47 │   │                                                                                                       │
│    48 │   │   self._loop.add_signal_handler(signal.SIGINT, serve.cancel)                                          │
│    49 │   │   self._loop.add_signal_handler(signal.SIGTERM, serve.cancel)                                         │
│ ❱  50 │   │   self._loop.run_until_complete(serve)                                                                │
│    51 │                                                                                                           │
│    52 │   async def _run_initial_coros(self):                                                                     │
│    53 │   │   for coro in self._initial_coros:                                                                    │
│                                                                                                                   │
│ ╭─────────────────────────────────────────────────── locals ────────────────────────────────────────────────────╮ │
│ │ interactive = True                                                                                            │ │
│ │        self = <fastcs.control_system.FastCS object at 0x750e031757d0>                                         │ │
│ │       serve = <Task finished name='Task-1' coro=<FastCS.serve() done, defined at                              │ │
│ │               /venv/lib/python3.11/site-packages/fastcs/control_system.py:80> exception=1 validation error    │ │
│ │               for EigerParameterResponse                                                                      │ │
│ │               access_mode                                                                                     │ │
│ │                 Field required [type=missing, input_value={'value': 'up', 'state': ...tical_values':          │ │
│ │               ['down']}, input_type=dict]                                                                     │ │
│ │               │   For further information visit https://errors.pydantic.dev/2.12/v/missing>                   │ │
│ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                                   │
│ /usr/local/lib/python3.11/asyncio/base_events.py:654 in run_until_complete                                        │
│                                                                                                                   │
│    651 │   │   if not future.done():                                                                              │
│    652 │   │   │   raise RuntimeError('Event loop stopped before Future completed.')                              │
│    653 │   │                                                                                                      │
│ ❱  654 │   │   return future.result()                                                                             │
│    655 │                                                                                                          │
│    656 │   def stop(self):                                                                                        │
│    657 │   │   """Stop running the event loop.                                                                    │
│                                                                                                                   │
│ ╭─────────────────────────────────────────────────── locals ────────────────────────────────────────────────────╮ │
│ │   future = <Task finished name='Task-1' coro=<FastCS.serve() done, defined at                                 │ │
│ │            /venv/lib/python3.11/site-packages/fastcs/control_system.py:80> exception=1 validation error for   │ │
│ │            EigerParameterResponse                                                                             │ │
│ │            access_mode                                                                                        │ │
│ │              Field required [type=missing, input_value={'value': 'up', 'state': ...tical_values': ['down']},  │ │
│ │            input_type=dict]                                                                                   │ │
│ │            │   For further information visit https://errors.pydantic.dev/2.12/v/missing>                      │ │
│ │ new_task = False                                                                                              │ │
│ │     self = <_UnixSelectorEventLoop running=False closed=False debug=False>                                    │ │
│ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                                                   │
│ /venv/lib/python3.11/site-packages/fastcs/control_system.py:81 in serve                                           │
│                                                                                                                   │
│    78 │   │   self._scan_tasks.clear()                                                                            │
│    79 │                                                                                                           │
│    80 │   async def serve(self, interactive: bool = True) -> None:                                                │
│ ❱  81 │   │   await self._controller.initialise()                                                                 │
│    82 │   │   self._controller.post_initialise()                                                                  │
│    83 │   │                                                                                                       │
│    84 │   │   self.controller_api = build_controller_api(self._controller)                                        │
│                                                                                                                   │
│ ╭─────────────────────────────── locals ────────────────────────────────╮                                         │
│ │ interactive = True                                                    │                                         │
│ │        self = <fastcs.control_system.FastCS object at 0x750e031757d0> │                                         │
│ ╰───────────────────────────────────────────────────────────────────────╯                                         │
│                                                                                                                   │
│ /venv/lib/python3.11/site-packages/fastcs_eiger/controllers/odin/eiger_odin_controller.py:25 in initialise        │
│                                                                                                                   │
│   22 │   async def initialise(self) -> None:                                                                      │
│   23 │   │   """Initialise eiger controller and odin controller"""                                                │
│   24 │   │                                                                                                        │
│ ❱ 25 │   │   await asyncio.gather(super().initialise(), self.OD.initialise())                                     │
│   26 │                                                                                                            │
│   27 │   @command()                                                                                               │
│   28 │   async def arm_when_ready(self):                                                                          │
│                                                                                                                   │
│ ╭───────────────────────────────── locals ──────────────────────────────────╮                                     │
│ │ self = EigerOdinController(path=None, sub_controllers=['OD', 'detector']) │                                     │
│ ╰───────────────────────────────────────────────────────────────────────────╯                                     │
│                                                                                                                   │
│ /venv/lib/python3.11/site-packages/fastcs_eiger/controllers/eiger_controller.py:83 in initialise                  │
│                                                                                                                   │
│    80 │   │   │   │   │   │   │   f"No subcontroller implemented for subsystem {subsystem}"                       │
│    81 │   │   │   │   │   │   )                                                                                   │
│    82 │   │   │   │   self.add_sub_controller(subsystem, controller)                                              │
│ ❱  83 │   │   │   │   await controller.initialise()                                                               │
│    84 │   │                                                                                                       │
│    85 │   │   except HTTPRequestError:                                                                            │
│    86 │   │   │   print("\nAn HTTP request failed while introspecting detector:\n")                               │
│                                                                                                                   │
│ ╭──────────────────────────────────── locals ─────────────────────────────────────╮                               │
│ │ controller = EigerDetectorController(path=detector, sub_controllers=None)       │                               │
│ │       self = EigerOdinController(path=None, sub_controllers=['OD', 'detector']) │                               │
│ │  state_val = {                                                                  │                               │
│ │              │   'value': 'idle',                                               │                               │
│ │              │   'state': 'normal',                                             │                               │
│ │              │   'value_type': 'string',                                        │                               │
│ │              │   'critical_limits': [None, None],                               │                               │
│ │              │   'time': '2026-02-06T01:12:45.272659',                          │                               │
│ │              │   'unit': '',                                                    │                               │
│ │              │   'critical_values': ['na', 'error']                             │                               │
│ │              }                                                                  │                               │
│ │  subsystem = 'detector'                                                         │                               │
│ ╰─────────────────────────────────────────────────────────────────────────────────╯                               │
│                                                                                                                   │
│ /venv/lib/python3.11/site-packages/fastcs_eiger/controllers/eiger_subsystem_controller.py:97 in initialise        │
│                                                                                                                   │
│    94 │   │   return parameters                                                                                   │
│    95 │                                                                                                           │
│    96 │   async def initialise(self) -> None:                                                                     │
│ ❱  97 │   │   parameters = await self._introspect_detector_subsystem()                                            │
│    98 │   │   attributes = self._create_attributes(parameters)                                                    │
│    99 │   │                                                                                                       │
│   100 │   │   for name, attribute in attributes.items():                                                          │
│                                                                                                                   │
│ ╭────────────────────────────── locals ───────────────────────────────╮                                           │
│ │ self = EigerDetectorController(path=detector, sub_controllers=None) │                                           │
│ ╰─────────────────────────────────────────────────────────────────────╯                                           │
│                                                                                                                   │
│ /venv/lib/python3.11/site-packages/fastcs_eiger/controllers/eiger_subsystem_controller.py:82 in                   │
│ _introspect_detector_subsystem                                                                                    │
│                                                                                                                   │
│    79 │   │   │   responses = await asyncio.gather(*requests)                                                     │
│    80 │   │   │                                                                                                   │
│    81 │   │   │   parameters.extend(                                                                              │
│ ❱  82 │   │   │   │   [                                                                                           │
│    83 │   │   │   │   │   EigerParameterRef(                                                                      │
│    84 │   │   │   │   │   │   key=key,                                                                            │
│    85 │   │   │   │   │   │   subsystem=self._subsystem,                                                          │
│                                                                                                                   │
│ ╭─────────────────────────────────── locals ────────────────────────────────────╮                                 │
│ │           mode = 'status'                                                     │                                 │
│ │     parameters = []                                                           │                                 │
│ │       requests = [                                                            │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03178c40>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179040>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179140>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179240>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179340>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179440>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179540>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179640>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179740>, │                                 │
│ │                  │   <coroutine object HTTPConnection.get at 0x750e03179840>, │                                 │
│ │                  │   ... +59                                                  │                                 │
│ │                  ]                                                            │                                 │
│ │      responses = [                                                            │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 'up',                                       │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'string',                              │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-02T18:22:41.667264',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': ['down']                          │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 'idle',                                     │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'string',                              │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-06T01:12:45.272659',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': ['na', 'error']                   │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 256,                                        │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'long',                                │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-02T18:22:41.666939',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': []                                │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 27.299999999999955,                         │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'float',                               │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-02T18:22:41.666913',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': []                                │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 2.49707,                                    │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'float',                               │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-02T18:22:41.666933',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': []                                │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 1.0,                                        │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'float',                               │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-02T18:22:41.666925',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': []                                │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 1,                                          │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'long',                                │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-02T18:22:41.667165',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': []                                │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 1,                                          │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'int',                                 │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-02T18:22:41.666989',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': []                                │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': 'ready',                                    │                                 │
│ │                  │   │   'state': 'normal',                                   │                                 │
│ │                  │   │   'value_type': 'string',                              │                                 │
│ │                  │   │   'critical_limits': [None, None],                     │                                 │
│ │                  │   │   'time': '2026-02-06T01:02:45.166145',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': ['na', 'error']                   │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   {                                                        │                                 │
│ │                  │   │   'value': None,                                       │                                 │
│ │                  │   │   'state': 'disabled',                                 │                                 │
│ │                  │   │   'value_type': 'NoneType',                            │                                 │
│ │                  │   │   'critical_limits': [0.0, 100.0],                     │                                 │
│ │                  │   │   'time': '2026-02-02T18:22:41.667098',                │                                 │
│ │                  │   │   'unit': '',                                          │                                 │
│ │                  │   │   'critical_values': []                                │                                 │
│ │                  │   },                                                       │                                 │
│ │                  │   ... +59                                                  │                                 │
│ │                  ]                                                            │                                 │
│ │           self = EigerDetectorController(path=detector, sub_controllers=None) │                                 │
│ │ subsystem_keys = [                                                            │                                 │
│ │                  │   'link_0',                                                │                                 │
│ │                  │   'state',                                                 │                                 │
│ │                  │   'board_000/fpga_fw',                                     │                                 │
│ │                  │   'board_000/fpga_temp',                                   │                                 │
│ │                  │   'board_000/fpga_vccaux',                                 │                                 │
│ │                  │   'board_000/fpga_vccint',                                 │                                 │
│ │                  │   'board_000/link_mode',                                   │                                 │
│ │                  │   'board_000/module_power',                                │                                 │
│ │                  │   'board_000/state',                                       │                                 │
│ │                  │   'board_000/th1_humidity',                                │                                 │
│ │                  │   ... +59                                                  │                                 │
│ │                  ]                                                            │                                 │
│ ╰───────────────────────────────────────────────────────────────────────────────╯                                 │
│                                                                                                                   │
│ /venv/lib/python3.11/site-packages/fastcs_eiger/controllers/eiger_subsystem_controller.py:87 in <listcomp>        │
│                                                                                                                   │
│    84 │   │   │   │   │   │   key=key,                                                                            │
│    85 │   │   │   │   │   │   subsystem=self._subsystem,                                                          │
│    86 │   │   │   │   │   │   mode=mode,                                                                          │
│ ❱  87 │   │   │   │   │   │   response=EigerParameterResponse.model_validate(response),                           │
│    88 │   │   │   │   │   │   update_period=ONCE if mode == "config" else 0.2,                                    │
│    89 │   │   │   │   │   )                                                                                       │
│    90 │   │   │   │   │   for key, response in zip(subsystem_keys, responses, strict=False)                       │
│                                                                                                                   │
│ ╭──────────────────────────────── locals ─────────────────────────────────╮                                       │
│ │       .0 = <zip object at 0x750e021b6380>                               │                                       │
│ │      key = 'link_0'                                                     │                                       │
│ │     mode = 'status'                                                     │                                       │
│ │ response = {                                                            │                                       │
│ │            │   'value': 'up',                                           │                                       │
│ │            │   'state': 'normal',                                       │                                       │
│ │            │   'value_type': 'string',                                  │                                       │
│ │            │   'critical_limits': [None, None],                         │                                       │
│ │            │   'time': '2026-02-02T18:22:41.667264',                    │                                       │
│ │            │   'unit': '',                                              │                                       │
│ │            │   'critical_values': ['down']                              │                                       │
│ │            }                                                            │                                       │
│ │     self = EigerDetectorController(path=detector, sub_controllers=None) │                                       │
│ ╰─────────────────────────────────────────────────────────────────────────╯                                       │
│                                                                                                                   │
│ /venv/lib/python3.11/site-packages/pydantic/main.py:716 in model_validate                                         │
│                                                                                                                   │
│    713 │   │   │   │   code='validate-by-alias-and-name-false',                                                   │
│    714 │   │   │   )                                                                                              │
│    715 │   │                                                                                                      │
│ ❱  716 │   │   return cls.__pydantic_validator__.validate_python(                                                 │
│    717 │   │   │   obj,                                                                                           │
│    718 │   │   │   strict=strict,                                                                                 │
│    719 │   │   │   extra=extra,                                                                                   │
│                                                                                                                   │
│ ╭────────────────────────── locals ───────────────────────────╮                                                   │
│ │        by_alias = None                                      │                                                   │
│ │         by_name = None                                      │                                                   │
│ │         context = None                                      │                                                   │
│ │           extra = None                                      │                                                   │
│ │ from_attributes = None                                      │                                                   │
│ │             obj = {                                         │                                                   │
│ │                   │   'value': 'up',                        │                                                   │
│ │                   │   'state': 'normal',                    │                                                   │
│ │                   │   'value_type': 'string',               │                                                   │
│ │                   │   'critical_limits': [None, None],      │                                                   │
│ │                   │   'time': '2026-02-02T18:22:41.667264', │                                                   │
│ │                   │   'unit': '',                           │                                                   │
│ │                   │   'critical_values': ['down']           │                                                   │
│ │                   }                                         │                                                   │
│ │          strict = None                                      │                                                   │
│ ╰─────────────────────────────────────────────────────────────╯                                                   │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
ValidationError: 1 validation error for EigerParameterResponse
access_mode
  Field required [type=missing, input_value={'value': 'up', 'state': ...tical_values': ['down']}, input_type=dict]
    For further information visit https://errors.pydantic.dev/2.12/v/missing

Based on the difference in APIs, DECTRIS has prepared for us the following table:

SIMPLON difference of 1.6.0 and 1.8.0 - simplon_diff_table.pdf

API references are:

SIMPLON_APIReference_v1p8.pdf

SIMPLON_APIReference_v1p6.pdf

[GDYendell]

The error suggests there is no access_mode in the response, but the manual suggests there should be... Ah but that is only for detector/config.

Just to confirm, what do you get for the following?

❯ curl http://i03-eiger01/detector/api/1.8.0/status/state
{"access_mode":"r","allowed_values":["na","idle","ready","acquire","configure","initialize","error"],"value":"ready","value_type":"string"}
❯ curl http://i03-eiger01/detector/api/1.8.0/config/trigger_mode
{"access_mode":"rw","allowed_values":["eies","exte","extg","exts","inte","ints"],"value":"exts","value_type":"string"}

I suggest we make access_mode optional on EigerParameterResponse and add an access_mode property to EigerParameterRef that returns response.access_mode if it is not None and otherwise assumes it based on mode:

• status -> "r"
• config -> "rw"

[toqduj]

That would be

{"value": "idle", "state": "normal", "value_type": "string", "critical_limits": [null, null], "time": "2026-02-06T16:12:58.335307", "unit": "", "critical_values": ["na", "error"]}

and

{"access_mode": "rw", "value_type": "string", "value": "ints", "allowed_values": ["ints", "exts", "inte", "exte"]}