ophyd-async 0.8.0a6__py3-none-any.whl → 0.9.0__py3-none-any.whl

ophyd_async/epics/sim/_ioc.py

@@ -0,0 +1,29 @@
+import atexit
+from pathlib import Path
+
+from ophyd_async.epics.testing import TestingIOC
+
+HERE = Path(__file__).absolute().parent
+
+
+def start_ioc_subprocess(prefix: str, num_counters: int):
+    """Start an IOC subprocess with EPICS database for sample stage and sensor
+    with the same pv prefix
+    """
+    ioc = TestingIOC()
+    # Create X and Y motors
+    for suffix in ["X", "Y"]:
+        ioc.add_database(HERE / "mover.db", P=f"{prefix}STAGE:{suffix}:")
+    # Create a multichannel counter with num_counters
+    ioc.add_database(HERE / "multichannelcounter.db", P=f"{prefix}MCC:")
+    for i in range(1, num_counters + 1):
+        ioc.add_database(
+            HERE / "counter.db",
+            P=f"{prefix}MCC:",
+            CHANNEL=str(i),
+            X=f"{prefix}STAGE:X:",
+            Y=f"{prefix}STAGE:Y:",
+        )
+    # Start IOC and register it to be stopped at exit
+    ioc.start()
+    atexit.register(ioc.stop)

ophyd_async/epics/{demo → sim}/_mover.py

@@ -37,8 +37,8 @@ class Mover(StandardReadable, Movable, Stoppable):
 
         super().__init__(name=name)
 
-    def set_name(self, name: str):
-        super().set_name(name)
+    def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
+        super().set_name(name, child_name_separator=child_name_separator)
         # Readback should be named the same as its parent in read()
         self.readback.set_name(name)
 
@@ -52,13 +52,19 @@ class Mover(StandardReadable, Movable, Stoppable):
             self.precision.get_value(),
             self.velocity.get_value(),
         )
-        if timeout == CALCULATE_TIMEOUT:
-            assert velocity > 0, "Mover has zero velocity"
-            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
+        if timeout is CALCULATE_TIMEOUT:
+            try:
+                timeout = (
+                    abs((new_position - old_position) / velocity) + DEFAULT_TIMEOUT
+                )
+            except ZeroDivisionError as error:
+                msg = "Mover has zero velocity"
+                raise ValueError(msg) from error
+
         # Make an Event that will be set on completion, and a Status that will
         # error if not done in time
         done = asyncio.Event()
-        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))
+        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))  # type: ignore
         # Wait for the value to set, but don't wait for put completion callback
         await self.setpoint.set(new_position, wait=False)
         async for current_position in observe_value(

ophyd_async/epics/{demo → sim}/_sensor.py

@@ -15,9 +15,9 @@ class EnergyMode(StrictEnum):
     """Energy mode for `Sensor`"""
 
     #: Low energy mode
-    low = "Low Energy"
+    LOW = "Low Energy"
     #: High energy mode
-    high = "High Energy"
+    HIGH = "High Energy"
 
 
 class Sensor(StandardReadable, EpicsDevice):

ophyd_async/epics/testing/__init__.py

@@ -1,24 +1,24 @@
 from ._example_ioc import (
     CA_PVA_RECORDS,
     PVA_RECORDS,
-    ExampleCaDevice,
-    ExampleEnum,
-    ExamplePvaDevice,
-    ExampleTable,
-    connect_example_device,
-    get_example_ioc,
+    EpicsTestCaDevice,
+    EpicsTestEnum,
+    EpicsTestIocAndDevices,
+    EpicsTestPvaDevice,
+    EpicsTestSubsetEnum,
+    EpicsTestTable,
 )
-from ._utils import TestingIOC, generate_random_PV_prefix
+from ._utils import TestingIOC, generate_random_pv_prefix
 
 __all__ = [
     "CA_PVA_RECORDS",
     "PVA_RECORDS",
-    "ExampleCaDevice",
-    "ExampleEnum",
-    "ExamplePvaDevice",
-    "ExampleTable",
-    "connect_example_device",
-    "get_example_ioc",
+    "EpicsTestCaDevice",
+    "EpicsTestEnum",
+    "EpicsTestSubsetEnum",
+    "EpicsTestPvaDevice",
+    "EpicsTestTable",
+    "EpicsTestIocAndDevices",
     "TestingIOC",
-    "generate_random_PV_prefix",
+    "generate_random_pv_prefix",
 ]

ophyd_async/epics/testing/_example_ioc.py

@@ -1,48 +1,50 @@
 from collections.abc import Sequence
 from pathlib import Path
 from typing import Annotated as A
-from typing import Literal
 
 import numpy as np
 
-from ophyd_async.core import (
-    Array1D,
-    SignalRW,
-    StrictEnum,
-    Table,
-)
-from ophyd_async.epics.core import (
-    EpicsDevice,
-    PvSuffix,
-)
+from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, Table
+from ophyd_async.core._utils import SubsetEnum
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
-from ._utils import TestingIOC
+from ._utils import TestingIOC, generate_random_pv_prefix
 
-CA_PVA_RECORDS = str(Path(__file__).parent / "test_records.db")
-PVA_RECORDS = str(Path(__file__).parent / "test_records_pva.db")
+CA_PVA_RECORDS = Path(__file__).parent / "test_records.db"
+PVA_RECORDS = Path(__file__).parent / "test_records_pva.db"
 
 
-class ExampleEnum(StrictEnum):
-    a = "Aaa"
-    b = "Bbb"
-    c = "Ccc"
+class EpicsTestEnum(StrictEnum):
+    A = "Aaa"
+    B = "Bbb"
+    C = "Ccc"
 
 
-class ExampleTable(Table):
+class EpicsTestSubsetEnum(SubsetEnum):
+    A = "Aaa"
+    B = "Bbb"
+
+
+class EpicsTestTable(Table):
     bool: Array1D[np.bool_]
     int: Array1D[np.int32]
     float: Array1D[np.float64]
     str: Sequence[str]
-    enum: Sequence[ExampleEnum]
+    enum: Sequence[EpicsTestEnum]
 
 
-class ExampleCaDevice(EpicsDevice):
+class EpicsTestCaDevice(EpicsDevice):
     my_int: A[SignalRW[int], PvSuffix("int")]
     my_float: A[SignalRW[float], PvSuffix("float")]
+    float_prec_0: A[SignalRW[int], PvSuffix("float_prec_0")]
     my_str: A[SignalRW[str], PvSuffix("str")]
+    longstr: A[SignalRW[str], PvSuffix("longstr")]
+    longstr2: A[SignalRW[str], PvSuffix("longstr2.VAL$")]
     my_bool: A[SignalRW[bool], PvSuffix("bool")]
-    enum: A[SignalRW[ExampleEnum], PvSuffix("enum")]
-    enum2: A[SignalRW[ExampleEnum], PvSuffix("enum2")]
+    enum: A[SignalRW[EpicsTestEnum], PvSuffix("enum")]
+    enum2: A[SignalRW[EpicsTestEnum], PvSuffix("enum2")]
+    subset_enum: A[SignalRW[EpicsTestSubsetEnum], PvSuffix("subset_enum")]
+    enum_str_fallback: A[SignalRW[str], PvSuffix("enum_str_fallback")]
     bool_unnamed: A[SignalRW[bool], PvSuffix("bool_unnamed")]
     partialint: A[SignalRW[int], PvSuffix("partialint")]
     lessint: A[SignalRW[int], PvSuffix("lessint")]
@@ -54,52 +56,36 @@ class ExampleCaDevice(EpicsDevice):
     stra: A[SignalRW[Sequence[str]], PvSuffix("stra")]
 
 
-class ExamplePvaDevice(ExampleCaDevice):  # pva can support all signal types that ca can
+class EpicsTestPvaDevice(EpicsTestCaDevice):
+    # pva can support all signal types that ca can
     int8a: A[SignalRW[Array1D[np.int8]], PvSuffix("int8a")]
     uint16a: A[SignalRW[Array1D[np.uint16]], PvSuffix("uint16a")]
     uint32a: A[SignalRW[Array1D[np.uint32]], PvSuffix("uint32a")]
     int64a: A[SignalRW[Array1D[np.int64]], PvSuffix("int64a")]
     uint64a: A[SignalRW[Array1D[np.uint64]], PvSuffix("uint64a")]
-    table: A[SignalRW[ExampleTable], PvSuffix("table")]
-    ntndarray_data: A[SignalRW[Array1D[np.int64]], PvSuffix("ntndarray:data")]
-
-
-async def connect_example_device(
-    ioc: TestingIOC, protocol: Literal["ca", "pva"]
-) -> ExamplePvaDevice | ExampleCaDevice:
-    """Helper function to return a connected example device.
-
-    Parameters
-    ----------
-
-    ioc: TestingIOC
-        TestingIOC configured to provide the records needed for the device
-
-    protocol: Literal["ca", "pva"]
-        The transport protocol of the device
-
-    Returns
-    -------
-    ExamplePvaDevice | ExampleCaDevice
-        a connected EpicsDevice with signals of many EPICS record types
-    """
-    device_cls = ExamplePvaDevice if protocol == "pva" else ExampleCaDevice
-    device = device_cls(f"{protocol}://{ioc.prefix_for(device_cls)}")
-    await device.connect()
-    return device
-
-
-def get_example_ioc() -> TestingIOC:
-    """Get TestingIOC instance with the example databases loaded.
-
-    Returns
-    -------
-    TestingIOC
-        instance with test_records.db loaded for ExampleCaDevice and
-        test_records.db and test_records_pva.db loaded for ExamplePvaDevice.
-    """
-    ioc = TestingIOC()
-    ioc.database_for(PVA_RECORDS, ExamplePvaDevice)
-    ioc.database_for(CA_PVA_RECORDS, ExamplePvaDevice)
-    ioc.database_for(CA_PVA_RECORDS, ExampleCaDevice)
-    return ioc
+    table: A[SignalRW[EpicsTestTable], PvSuffix("table")]
+    ntndarray: A[SignalR[np.ndarray], PvSuffix("ntndarray")]
+
+
+class EpicsTestIocAndDevices:
+    def __init__(self):
+        self.prefix = generate_random_pv_prefix()
+        self.ioc = TestingIOC()
+        # Create supporting records and ExampleCaDevice
+        ca_prefix = f"{self.prefix}ca:"
+        self.ioc.add_database(CA_PVA_RECORDS, device=ca_prefix)
+        self.ca_device = EpicsTestCaDevice(f"ca://{ca_prefix}")
+        # Create supporting records and ExamplePvaDevice
+        pva_prefix = f"{self.prefix}pva:"
+        self.ioc.add_database(CA_PVA_RECORDS, device=pva_prefix)
+        self.ioc.add_database(PVA_RECORDS, device=pva_prefix)
+        self.pva_device = EpicsTestPvaDevice(f"pva://{pva_prefix}")
+
+    def get_device(self, protocol: str) -> EpicsTestCaDevice | EpicsTestPvaDevice:
+        return getattr(self, f"{protocol}_device")
+
+    def get_signal(self, protocol: str, name: str) -> SignalRW:
+        return getattr(self.get_device(protocol), name)
+
+    def get_pv(self, protocol: str, name: str) -> str:
+        return f"{protocol}://{self.prefix}{protocol}:{name}"

ophyd_async/epics/testing/_utils.py

@@ -5,50 +5,28 @@ import sys
 import time
 from pathlib import Path
 
-from aioca import purge_channel_caches
 
-from ophyd_async.core import Device
-
-
-def generate_random_PV_prefix() -> str:
+def generate_random_pv_prefix() -> str:
     return "".join(random.choice(string.ascii_lowercase) for _ in range(12)) + ":"
 
 
 class TestingIOC:
-    _dbs: dict[type[Device], list[Path]] = {}
-    _prefixes: dict[type[Device], str] = {}
-
-    @classmethod
-    def with_database(cls, db: Path | str):  # use as a decorator
-        def inner(device_cls: type[Device]):
-            cls.database_for(db, device_cls)
-            return device_cls
-
-        return inner
-
-    @classmethod
-    def database_for(cls, db, device_cls):
-        path = Path(db)
-        if not path.is_file():
-            raise OSError(f"{path} is not a file.")
-        if device_cls not in cls._dbs:
-            cls._dbs[device_cls] = []
-        cls._dbs[device_cls].append(path)
+    def __init__(self):
+        self._db_macros: list[tuple[Path, dict[str, str]]] = []
+        self.output = ""
 
-    def prefix_for(self, device_cls):
-        # generate random prefix, return existing if already generated
-        return self._prefixes.setdefault(device_cls, generate_random_PV_prefix())
+    def add_database(self, db: Path | str, /, **macros: str):
+        self._db_macros.append((Path(db), macros))
 
-    def start_ioc(self):
+    def start(self):
         ioc_args = [
             sys.executable,
             "-m",
             "epicscorelibs.ioc",
         ]
-        for device_cls, dbs in self._dbs.items():
-            prefix = self.prefix_for(device_cls)
-            for db in dbs:
-                ioc_args += ["-m", f"device={prefix}", "-d", str(db)]
+        for db, macros in self._db_macros:
+            macro_str = ",".join(f"{k}={v}" for k, v in macros.items())
+            ioc_args += ["-m", macro_str, "-d", str(db)]
         self._process = subprocess.Popen(
             ioc_args,
             stdin=subprocess.PIPE,
@@ -56,23 +34,17 @@ class TestingIOC:
             stderr=subprocess.STDOUT,
             universal_newlines=True,
         )
+        assert self._process.stdout  # noqa: S101 # this is to make Pylance happy
         start_time = time.monotonic()
-        while "iocRun: All initialization complete" not in (
-            self._process.stdout.readline().strip()  # type: ignore
-        ):
+        while "iocRun: All initialization complete" not in self.output:
             if time.monotonic() - start_time > 10:
-                try:
-                    print(self._process.communicate("exit()")[0])
-                except ValueError:
-                    # Someone else already called communicate
-                    pass
-                raise TimeoutError("IOC did not start in time")
+                self.stop()
+                raise TimeoutError(f"IOC did not start in time:\n{self.output}")
+            self.output += self._process.stdout.readline()
 
-    def stop_ioc(self):
-        # close backend caches before the event loop
-        purge_channel_caches()
+    def stop(self):
         try:
-            print(self._process.communicate("exit()")[0])
+            self.output += self._process.communicate("exit()")[0]
         except ValueError:
             # Someone else already called communicate
             pass

ophyd_async/epics/testing/test_records.db

@@ -96,6 +96,22 @@ record(mbbo, "$(device)enum2") {
   field(PINI, "YES")
 }
 
+record(mbbo, "$(device)subset_enum") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(mbbo, "$(device)enum_str_fallback") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
 record(waveform, "$(device)uint8a") {
   field(NELM, "3")
   field(FTVL, "UCHAR")
@@ -150,3 +166,9 @@ record(lsi, "$(device)longstr2") {
   field(INP, {const:"a string that is just longer than forty characters"})
   field(PINI, "YES")
 }
+
+record(calc, "$(device)ticking") {
+  field(INPA, "$(device)ticking")
+  field(CALC, "A+1")
+  field(SCAN, ".1 second")
+}

ophyd_async/fastcs/core.py

@@ -2,8 +2,8 @@ from ophyd_async.core import Device, DeviceConnector
 from ophyd_async.epics.core import PviDeviceConnector
 
 
-def fastcs_connector(device: Device, uri: str) -> DeviceConnector:
+def fastcs_connector(device: Device, uri: str, error_hint: str = "") -> DeviceConnector:
     # TODO: add Tango support based on uri scheme
-    connector = PviDeviceConnector(uri)
+    connector = PviDeviceConnector(uri, error_hint)
     connector.create_children_from_annotations(device)
     return connector

ophyd_async/fastcs/panda/__init__.py

@@ -23,7 +23,6 @@ from ._trigger import (
     StaticPcompTriggerLogic,
     StaticSeqTableTriggerLogic,
 )
-from ._utils import phase_sorter
 from ._writer import PandaHDFWriter
 
 __all__ = [
@@ -47,5 +46,4 @@ __all__ = [
     "SeqTableInfo",
     "StaticPcompTriggerLogic",
     "StaticSeqTableTriggerLogic",
-    "phase_sorter",
 ]

ophyd_async/fastcs/panda/_block.py

@@ -36,14 +36,14 @@ class PulseBlock(Device):
 
 
 class PcompDirection(StrictEnum):
-    positive = "Positive"
-    negative = "Negative"
-    either = "Either"
+    POSITIVE = "Positive"
+    NEGATIVE = "Negative"
+    EITHER = "Either"
 
 
 class BitMux(SubsetEnum):
-    zero = "ZERO"
-    one = "ONE"
+    ZERO = "ZERO"
+    ONE = "ONE"
 
 
 class PcompBlock(Device):
@@ -57,10 +57,10 @@ class PcompBlock(Device):
 
 
 class TimeUnits(StrictEnum):
-    min = "min"
-    s = "s"
-    ms = "ms"
-    us = "us"
+    MIN = "min"
+    S = "s"
+    MS = "ms"
+    US = "us"
 
 
 class SeqBlock(Device):

ophyd_async/fastcs/panda/_control.py

@@ -18,10 +18,15 @@ class PandaPcapController(DetectorController):
         return 0.000000008
 
     async def prepare(self, trigger_info: TriggerInfo):
-        assert trigger_info.trigger in (
-            DetectorTrigger.constant_gate,
-            DetectorTrigger.variable_gate,
-        ), "Only constant_gate and variable_gate triggering is supported on the PandA"
+        if trigger_info.trigger not in (
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.VARIABLE_GATE,
+        ):
+            msg = (
+                "Only constant_gate and variable_gate triggering is supported on "
+                "the PandA",
+            )
+            raise TypeError(msg)
 
     async def arm(self):
         self._arm_status = self.pcap.arm.set(True)

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -9,8 +9,12 @@ from ._block import CommonPandaBlocks
 from ._control import PandaPcapController
 from ._writer import PandaHDFWriter
 
+MINIMUM_PANDA_IOC = "0.11.4"
 
-class HDFPanda(CommonPandaBlocks, StandardDetector):
+
+class HDFPanda(
+    CommonPandaBlocks, StandardDetector[PandaPcapController, PandaHDFWriter]
+):
     def __init__(
         self,
         prefix: str,
@@ -18,8 +22,9 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         config_sigs: Sequence[SignalR] = (),
         name: str = "",
     ):
+        error_hint = f"Is PandABlocks-ioc at least version {MINIMUM_PANDA_IOC}?"
         # This has to be first so we make self.pcap
-        connector = fastcs_connector(self, prefix)
+        connector = fastcs_connector(self, prefix, error_hint)
         controller = PandaPcapController(pcap=self.pcap)
         writer = PandaHDFWriter(
             path_provider=path_provider,

ophyd_async/fastcs/panda/_table.py

@@ -83,5 +83,8 @@ class SeqTable(Table):
         """
 
         first_length = len(self)
-        assert first_length <= 4096, f"Length {first_length} is too long"
+        max_length = 4096
+        if first_length > max_length:
+            msg = f"Length {first_length} is too long"
+            raise ValueError(msg)
         return self

ophyd_async/fastcs/panda/_trigger.py

@@ -20,8 +20,8 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
 
     async def prepare(self, value: SeqTableInfo):
         await asyncio.gather(
-            self.seq.prescale_units.set(TimeUnits.us),
-            self.seq.enable.set(BitMux.zero),
+            self.seq.prescale_units.set(TimeUnits.US),
+            self.seq.enable.set(BitMux.ZERO),
         )
         await asyncio.gather(
             self.seq.prescale.set(value.prescale_as_us),
@@ -30,14 +30,14 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.seq.enable.set(BitMux.one)
+        await self.seq.enable.set(BitMux.ONE)
         await wait_for_value(self.seq.active, True, timeout=1)
 
     async def complete(self) -> None:
         await wait_for_value(self.seq.active, False, timeout=None)
 
     async def stop(self):
-        await self.seq.enable.set(BitMux.zero)
+        await self.seq.enable.set(BitMux.ZERO)
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
@@ -68,7 +68,7 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         self.pcomp = pcomp
 
     async def prepare(self, value: PcompInfo):
-        await self.pcomp.enable.set(BitMux.zero)
+        await self.pcomp.enable.set(BitMux.ZERO)
         await asyncio.gather(
             self.pcomp.start.set(value.start_postion),
             self.pcomp.width.set(value.pulse_width),
@@ -78,12 +78,12 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.pcomp.enable.set(BitMux.one)
+        await self.pcomp.enable.set(BitMux.ONE)
         await wait_for_value(self.pcomp.active, True, timeout=1)
 
     async def complete(self, timeout: float | None = None) -> None:
         await wait_for_value(self.pcomp.active, False, timeout=timeout)
 
     async def stop(self):
-        await self.pcomp.enable.set(BitMux.zero)
+        await self.pcomp.enable.set(BitMux.ZERO)
         await wait_for_value(self.pcomp.active, False, timeout=1)

ophyd_async/plan_stubs/__init__.py

@@ -5,6 +5,14 @@ from ._fly import (
     time_resolved_fly_and_collect_with_static_seq_table,
 )
 from ._nd_attributes import setup_ndattributes, setup_ndstats_sum
+from ._panda import apply_panda_settings
+from ._settings import (
+    apply_settings,
+    apply_settings_if_different,
+    get_current_settings,
+    retrieve_settings,
+    store_settings,
+)
 
 __all__ = [
     "fly_and_collect",
@@ -13,4 +21,10 @@ __all__ = [
     "ensure_connected",
     "setup_ndattributes",
     "setup_ndstats_sum",
+    "apply_panda_settings",
+    "apply_settings",
+    "apply_settings_if_different",
+    "get_current_settings",
+    "retrieve_settings",
+    "store_settings",
 ]

ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,10 +1,11 @@
-from collections.abc import Awaitable
-
-import bluesky.plan_stubs as bps
+from bluesky.utils import plan
 
 from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
 
+from ._wait_for_awaitable import wait_for_awaitable
+
 
+@plan
 def ensure_connected(
     *devices: Device,
     mock: bool | LazyMock = False,
@@ -17,17 +18,10 @@ def ensure_connected(
     }
     if non_unique:
         raise ValueError(f"Devices do not have unique names {non_unique}")
-
-    def connect_devices() -> Awaitable[None]:
-        coros = {
-            device.name: device.connect(
-                mock=mock, timeout=timeout, force_reconnect=force_reconnect
-            )
-            for device in devices
-        }
-        return wait_for_connection(**coros)
-
-    (connect_task,) = yield from bps.wait_for([connect_devices])
-
-    if connect_task and connect_task.exception() is not None:
-        raise connect_task.exception()
+    coros = {
+        device.name: device.connect(
+            mock=mock, timeout=timeout, force_reconnect=force_reconnect
+        )
+        for device in devices
+    }
+    yield from wait_for_awaitable(wait_for_connection(**coros))

ophyd_async/plan_stubs/_fly.py

@@ -58,11 +58,11 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     if not detectors:
         raise ValueError("No detectors provided. There must be at least one.")
 
-    deadtime = max(det.controller.get_deadtime(exposure) for det in detectors)
+    deadtime = max(det._controller.get_deadtime(exposure) for det in detectors)  # noqa: SLF001
 
     trigger_info = TriggerInfo(
         number_of_triggers=number_of_frames * repeats,
-        trigger=DetectorTrigger.constant_gate,
+        trigger=DetectorTrigger.CONSTANT_GATE,
         deadtime=deadtime,
         livetime=exposure,
         frame_timeout=frame_timeout,