ophyd-async 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

ophyd_async/epics/_backend/_p4p.py

@@ -1,16 +1,16 @@
 import asyncio
 import atexit
-from asyncio import CancelledError
+import logging
+import time
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, List, Optional, Sequence, Type, Union
 
-from bluesky.protocols import Descriptor, Dtype, Reading
+from bluesky.protocols import DataKey, Dtype, Reading
 from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 
 from ophyd_async.core import (
-    NotConnected,
     ReadingValueCallback,
     SignalBackend,
     T,
@@ -18,6 +18,9 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
+
+from .common import get_supported_values
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {
@@ -46,15 +49,15 @@ class PvaConverter:
     def reading(self, value):
         ts = value["timeStamp"]
         sv = value["alarm"]["severity"]
-        return dict(
-            value=self.value(value),
-            timestamp=ts["secondsPastEpoch"] + ts["nanoseconds"] * 1e-9,
-            alarm_severity=-1 if sv > 2 else sv,
-        )
+        return {
+            "value": self.value(value),
+            "timestamp": ts["secondsPastEpoch"] + ts["nanoseconds"] * 1e-9,
+            "alarm_severity": -1 if sv > 2 else sv,
+        }
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         dtype = specifier_to_dtype[value.type().aspy("value")]
-        return dict(source=source, dtype=dtype, shape=[])
+        return {"source": source, "dtype": dtype, "shape": []}
 
     def metadata_fields(self) -> List[str]:
         """
@@ -70,8 +73,8 @@ class PvaConverter:
 
 
 class PvaArrayConverter(PvaConverter):
-    def descriptor(self, source: str, value) -> Descriptor:
-        return dict(source=source, dtype="array", shape=[len(value["value"])])
+    def get_datakey(self, source: str, value) -> DataKey:
+        return {"source": source, "dtype": "array", "shape": [len(value["value"])]}
 
 
 class PvaNDArrayConverter(PvaConverter):
@@ -93,9 +96,9 @@ class PvaNDArrayConverter(PvaConverter):
         dims = self._get_dimensions(value)
         return value["value"].reshape(dims)
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         dims = self._get_dimensions(value)
-        return dict(source=source, dtype="array", shape=dims)
+        return {"source": source, "dtype": "array", "shape": dims}
 
     def write_value(self, value):
         # No clear use-case for writing directly to an NDArray, and some
@@ -106,7 +109,8 @@ class PvaNDArrayConverter(PvaConverter):
 
 @dataclass
 class PvaEnumConverter(PvaConverter):
-    enum_class: Type[Enum]
+    def __init__(self, choices: dict[str, str]):
+        self.choices = tuple(choices.values())
 
     def write_value(self, value: Union[Enum, str]):
         if isinstance(value, Enum):
@@ -115,30 +119,58 @@ class PvaEnumConverter(PvaConverter):
             return value
 
     def value(self, value):
-        return list(self.enum_class)[value["value"]["index"]]
+        return self.choices[value["value"]["index"]]
 
-    def descriptor(self, source: str, value) -> Descriptor:
-        choices = [e.value for e in self.enum_class]
-        return dict(
-            source=source, dtype="string", shape=[], choices=choices
-        )  # type: ignore
+    def get_datakey(self, source: str, value) -> DataKey:
+        return {
+            "source": source,
+            "dtype": "string",
+            "shape": [],
+            "choices": list(self.choices),
+        }
 
 
 class PvaEnumBoolConverter(PvaConverter):
     def value(self, value):
         return value["value"]["index"]
 
-    def descriptor(self, source: str, value) -> Descriptor:
-        return dict(source=source, dtype="integer", shape=[])
+    def get_datakey(self, source: str, value) -> DataKey:
+        return {"source": source, "dtype": "integer", "shape": []}
 
 
 class PvaTableConverter(PvaConverter):
     def value(self, value):
         return value["value"].todict()
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         # This is wrong, but defer until we know how to actually describe a table
-        return dict(source=source, dtype="object", shape=[])  # type: ignore
+        return {"source": source, "dtype": "object", "shape": []}  # type: ignore
+
+
+class PvaDictConverter(PvaConverter):
+    def reading(self, value):
+        ts = time.time()
+        value = value.todict()
+        # Alarm severity is vacuously 0 for a table
+        return {"value": value, "timestamp": ts, "alarm_severity": 0}
+
+    def value(self, value: Value):
+        return value.todict()
+
+    def get_datakey(self, source: str, value) -> DataKey:
+        raise NotImplementedError("Describing Dict signals not currently supported")
+
+    def metadata_fields(self) -> List[str]:
+        """
+        Fields to request from PVA for metadata.
+        """
+        return []
+
+    def value_fields(self) -> List[str]:
+        """
+        Fields to request from PVA for the value.
+        """
+        return []
 
 
 class DisconnectedPvaConverter(PvaConverter):
@@ -149,7 +181,9 @@ class DisconnectedPvaConverter(PvaConverter):
 def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConverter:
     pv = list(values)[0]
     typeid = get_unique({k: v.getID() for k, v in values.items()}, "typeids")
-    typ = get_unique({k: type(v["value"]) for k, v in values.items()}, "value types")
+    typ = get_unique(
+        {k: type(v.get("value")) for k, v in values.items()}, "value types"
+    )
     if "NTScalarArray" in typeid and typ == list:
         # Waveform of strings, check we wanted this
         if datatype and datatype != Sequence[str]:
@@ -185,24 +219,21 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
         pv_choices = get_unique(
             {k: tuple(v["value"]["choices"]) for k, v in values.items()}, "choices"
         )
-        if datatype:
-            if not issubclass(datatype, Enum):
-                raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
-            choices = tuple(v.value for v in datatype)
-            if set(choices) != set(pv_choices):
-                raise TypeError(f"{pv} has choices {pv_choices} not {choices}")
-            enum_class = datatype
-        else:
-            enum_class = Enum(  # type: ignore
-                "GeneratedChoices", {x: x for x in pv_choices}, type=str
-            )
-        return PvaEnumConverter(enum_class)
+        return PvaEnumConverter(get_supported_values(pv, datatype, pv_choices))
     elif "NTScalar" in typeid:
-        if datatype and not issubclass(typ, datatype):
+        if (
+            datatype
+            and not issubclass(typ, datatype)
+            and not (
+                typ is float and datatype is int
+            )  # Allow float -> int since prec can be 0
+        ):
             raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
         return PvaConverter()
     elif "NTTable" in typeid:
         return PvaTableConverter()
+    elif "structure" in typeid:
+        return PvaDictConverter()
     else:
         raise TypeError(f"{pv}: Unsupported typeid {typeid}")
 
@@ -216,9 +247,11 @@ class PvaSignalBackend(SignalBackend[T]):
         self.write_pv = write_pv
         self.initial_values: Dict[str, Any] = {}
         self.converter: PvaConverter = DisconnectedPvaConverter()
-        self.source = f"pva://{self.read_pv}"
         self.subscription: Optional[Subscription] = None
 
+    def source(self, name: str):
+        return f"pva://{self.read_pv}"
+
     @property
     def ctxt(self) -> Context:
         if PvaSignalBackend._ctxt is None:
@@ -233,22 +266,25 @@ class PvaSignalBackend(SignalBackend[T]):
 
         return PvaSignalBackend._ctxt
 
-    async def _store_initial_value(self, pv):
+    async def _store_initial_value(self, pv, timeout: float = DEFAULT_TIMEOUT):
         try:
-            self.initial_values[pv] = await self.ctxt.get(pv)
-        except CancelledError:
-            raise NotConnected(self.source)
+            self.initial_values[pv] = await asyncio.wait_for(
+                self.ctxt.get(pv), timeout=timeout
+            )
+        except asyncio.TimeoutError as exc:
+            logging.debug(f"signal pva://{pv} timed out", exc_info=True)
+            raise NotConnected(f"pva://{pv}") from exc
 
-    async def connect(self):
+    async def connect(self, timeout: float = DEFAULT_TIMEOUT):
         if self.read_pv != self.write_pv:
             # Different, need to connect both
             await wait_for_connection(
-                read_pv=self._store_initial_value(self.read_pv),
-                write_pv=self._store_initial_value(self.write_pv),
+                read_pv=self._store_initial_value(self.read_pv, timeout=timeout),
+                write_pv=self._store_initial_value(self.write_pv, timeout=timeout),
             )
         else:
             # The same, so only need to connect one
-            await self._store_initial_value(self.read_pv)
+            await self._store_initial_value(self.read_pv, timeout=timeout)
         self.converter = make_converter(self.datatype, self.initial_values)
 
     async def put(self, value: Optional[T], wait=True, timeout=None):
@@ -256,12 +292,20 @@ class PvaSignalBackend(SignalBackend[T]):
             write_value = self.initial_values[self.write_pv]
         else:
             write_value = self.converter.write_value(value)
-        coro = self.ctxt.put(self.write_pv, dict(value=write_value), wait=wait)
-        await asyncio.wait_for(coro, timeout)
+        coro = self.ctxt.put(self.write_pv, {"value": write_value}, wait=wait)
+        try:
+            await asyncio.wait_for(coro, timeout)
+        except asyncio.TimeoutError as exc:
+            logging.debug(
+                f"signal pva://{self.write_pv} timed out \
+                          put value: {write_value}",
+                exc_info=True,
+            )
+            raise NotConnected(f"pva://{self.write_pv}") from exc
 
-    async def get_descriptor(self) -> Descriptor:
+    async def get_datakey(self, source: str) -> DataKey:
         value = await self.ctxt.get(self.read_pv)
-        return self.converter.descriptor(self.source, value)
+        return self.converter.get_datakey(source, value)
 
     def _pva_request_string(self, fields: List[str]) -> str:
         """
@@ -282,6 +326,10 @@ class PvaSignalBackend(SignalBackend[T]):
         value = await self.ctxt.get(self.read_pv, request=request)
         return self.converter.value(value)
 
+    async def get_setpoint(self) -> T:
+        value = await self.ctxt.get(self.write_pv, "field(value)")
+        return self.converter.value(value)
+
     def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
         if callback:
             assert (

ophyd_async/epics/_backend/common.py

@@ -0,0 +1,25 @@
+from enum import Enum
+from typing import Dict, Optional, Tuple, Type
+
+
+def get_supported_values(
+    pv: str,
+    datatype: Optional[Type[str]],
+    pv_choices: Tuple[str, ...],
+) -> Dict[str, str]:
+    if not datatype:
+        return {x: x or "_" for x in pv_choices}
+
+    if not issubclass(datatype, str):
+        raise TypeError(f"{pv} is type Enum but doesn't inherit from String")
+    if issubclass(datatype, Enum):
+        choices = tuple(v.value for v in datatype)
+        if set(choices) != set(pv_choices):
+            raise TypeError(
+                (
+                    f"{pv} has choices {pv_choices}, "
+                    f"which do not match {datatype}, which has {choices}"
+                )
+            )
+        return {x: datatype(x) for x in pv_choices}
+    return {x: x for x in pv_choices}

ophyd_async/epics/areadetector/__init__.py

@@ -1,22 +1,23 @@
-from .ad_driver import ADDriver
-from .directory_provider import DirectoryProvider, TmpDirectoryProvider
-from .hdf_streamer_det import HDFStreamerDet
-from .nd_file_hdf import NDFileHDF
-from .nd_plugin import NDPlugin, NDPluginStats
+from .aravis import AravisDetector
+from .kinetix import KinetixDetector
+from .pilatus import PilatusDetector
 from .single_trigger_det import SingleTriggerDet
-from .utils import FileWriteMode, ImageMode, ad_r, ad_rw
+from .utils import (
+    FileWriteMode,
+    ImageMode,
+    NDAttributeDataType,
+    NDAttributesXML,
+)
+from .vimba import VimbaDetector
 
 __all__ = [
-    "ADDriver",
-    "DirectoryProvider",
-    "TmpDirectoryProvider",
-    "HDFStreamerDet",
-    "NDFileHDF",
-    "NDPlugin",
-    "NDPluginStats",
+    "AravisDetector",
+    "KinetixDetector",
+    "VimbaDetector",
     "SingleTriggerDet",
     "FileWriteMode",
     "ImageMode",
-    "ad_r",
-    "ad_rw",
+    "NDAttributeDataType",
+    "NDAttributesXML",
+    "PilatusDetector",
 ]

ophyd_async/epics/areadetector/aravis.py

@@ -0,0 +1,63 @@
+from typing import get_args
+
+from bluesky.protocols import HasHints, Hints
+
+from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.epics.areadetector.controllers.aravis_controller import (
+    AravisController,
+)
+from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
+from ophyd_async.epics.areadetector.drivers.aravis_driver import AravisDriver
+from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
+
+
+class AravisDetector(StandardDetector, HasHints):
+    """
+    Ophyd-async implementation of an ADAravis Detector.
+    The detector may be configured for an external trigger on a GPIO port,
+    which must be done prior to preparing the detector
+    """
+
+    _controller: AravisController
+    _writer: HDFWriter
+
+    def __init__(
+        self,
+        prefix: str,
+        directory_provider: DirectoryProvider,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
+        gpio_number: AravisController.GPIO_NUMBER = 1,
+    ):
+        self.drv = AravisDriver(prefix + drv_suffix)
+        self.hdf = NDFileHDF(prefix + hdf_suffix)
+
+        super().__init__(
+            AravisController(self.drv, gpio_number=gpio_number),
+            HDFWriter(
+                self.hdf,
+                directory_provider,
+                lambda: self.name,
+                ADBaseShapeProvider(self.drv),
+            ),
+            config_sigs=(self.drv.acquire_time,),
+            name=name,
+        )
+
+    def get_external_trigger_gpio(self):
+        return self._controller.gpio_number
+
+    def set_external_trigger_gpio(self, gpio_number: AravisController.GPIO_NUMBER):
+        supported_gpio_numbers = get_args(AravisController.GPIO_NUMBER)
+        if gpio_number not in supported_gpio_numbers:
+            raise ValueError(
+                f"{self.__class__.__name__} only supports the following GPIO "
+                f"indices: {supported_gpio_numbers} but was asked to "
+                f"use {gpio_number}"
+            )
+        self._controller.gpio_number = gpio_number
+
+    @property
+    def hints(self) -> Hints:
+        return self._writer.hints

ophyd_async/epics/areadetector/controllers/__init__.py

@@ -0,0 +1,5 @@
+from .ad_sim_controller import ADSimController
+from .aravis_controller import AravisController
+from .pilatus_controller import PilatusController
+
+__all__ = ["PilatusController", "ADSimController", "AravisController"]

ophyd_async/epics/areadetector/controllers/ad_sim_controller.py

@@ -0,0 +1,52 @@
+import asyncio
+from typing import Optional, Set
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+)
+
+from ..drivers.ad_base import (
+    DEFAULT_GOOD_STATES,
+    ADBase,
+    DetectorState,
+    ImageMode,
+    start_acquiring_driver_and_ensure_status,
+)
+from ..utils import stop_busy_record
+
+
+class ADSimController(DetectorControl):
+    def __init__(
+        self, driver: ADBase, good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES)
+    ) -> None:
+        self.driver = driver
+        self.good_states = good_states
+
+    def get_deadtime(self, exposure: float) -> float:
+        return 0.002
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        assert (
+            trigger == DetectorTrigger.internal
+        ), "fly scanning (i.e. external triggering) is not supported for this device"
+        frame_timeout = DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        await asyncio.gather(
+            self.driver.num_images.set(num),
+            self.driver.image_mode.set(ImageMode.multiple),
+        )
+        return await start_acquiring_driver_and_ensure_status(
+            self.driver, good_states=self.good_states, timeout=frame_timeout
+        )
+
+    async def disarm(self):
+        # We can't use caput callback as we already used it in arm() and we can't have
+        # 2 or they will deadlock
+        await stop_busy_record(self.driver.acquire, False, timeout=1)

ophyd_async/epics/areadetector/controllers/aravis_controller.py

@@ -0,0 +1,78 @@
+import asyncio
+from typing import Literal, Optional, Tuple
+
+from ophyd_async.core import (
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    set_and_wait_for_value,
+)
+from ophyd_async.epics.areadetector.drivers.aravis_driver import (
+    AravisDriver,
+    AravisTriggerMode,
+    AravisTriggerSource,
+)
+from ophyd_async.epics.areadetector.utils import ImageMode, stop_busy_record
+
+# The deadtime of an ADaravis controller varies depending on the exact model of camera.
+# Ideally we would maximize performance by dynamically retrieving the deadtime at
+# runtime. See https://github.com/bluesky/ophyd-async/issues/308
+_HIGHEST_POSSIBLE_DEADTIME = 1961e-6
+
+
+class AravisController(DetectorControl):
+    GPIO_NUMBER = Literal[1, 2, 3, 4]
+
+    def __init__(self, driver: AravisDriver, gpio_number: GPIO_NUMBER) -> None:
+        self._drv = driver
+        self.gpio_number = gpio_number
+
+    def get_deadtime(self, exposure: float) -> float:
+        return _HIGHEST_POSSIBLE_DEADTIME
+
+    async def arm(
+        self,
+        num: int = 0,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        if num == 0:
+            image_mode = ImageMode.continuous
+        else:
+            image_mode = ImageMode.multiple
+        if exposure is not None:
+            await self._drv.acquire_time.set(exposure)
+
+        trigger_mode, trigger_source = self._get_trigger_info(trigger)
+        # trigger mode must be set first and on it's own!
+        await self._drv.trigger_mode.set(trigger_mode)
+
+        await asyncio.gather(
+            self._drv.trigger_source.set(trigger_source),
+            self._drv.num_images.set(num),
+            self._drv.image_mode.set(image_mode),
+        )
+
+        status = await set_and_wait_for_value(self._drv.acquire, True)
+        return status
+
+    def _get_trigger_info(
+        self, trigger: DetectorTrigger
+    ) -> Tuple[AravisTriggerMode, AravisTriggerSource]:
+        supported_trigger_types = (
+            DetectorTrigger.constant_gate,
+            DetectorTrigger.edge_trigger,
+        )
+        if trigger not in supported_trigger_types:
+            raise ValueError(
+                f"{self.__class__.__name__} only supports the following trigger "
+                f"types: {supported_trigger_types} but was asked to "
+                f"use {trigger}"
+            )
+        if trigger == DetectorTrigger.internal:
+            return AravisTriggerMode.off, "Freerun"
+        else:
+            return (AravisTriggerMode.on, f"Line{self.gpio_number}")
+
+    async def disarm(self):
+        await stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/areadetector/controllers/kinetix_controller.py

@@ -0,0 +1,49 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.epics.areadetector.drivers.ad_base import (
+    start_acquiring_driver_and_ensure_status,
+)
+
+from ..drivers.kinetix_driver import KinetixDriver, KinetixTriggerMode
+from ..utils import ImageMode, stop_busy_record
+
+KINETIX_TRIGGER_MODE_MAP = {
+    DetectorTrigger.internal: KinetixTriggerMode.internal,
+    DetectorTrigger.constant_gate: KinetixTriggerMode.gate,
+    DetectorTrigger.variable_gate: KinetixTriggerMode.gate,
+    DetectorTrigger.edge_trigger: KinetixTriggerMode.edge,
+}
+
+
+class KinetixController(DetectorControl):
+    def __init__(
+        self,
+        driver: KinetixDriver,
+    ) -> None:
+        self._drv = driver
+
+    def get_deadtime(self, exposure: float) -> float:
+        return 0.001
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        await asyncio.gather(
+            self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger]),
+            self._drv.num_images.set(num),
+            self._drv.image_mode.set(ImageMode.multiple),
+        )
+        if exposure is not None and trigger not in [
+            DetectorTrigger.variable_gate,
+            DetectorTrigger.constant_gate,
+        ]:
+            await self._drv.acquire_time.set(exposure)
+        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+    async def disarm(self):
+        await stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -0,0 +1,61 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core.detector import DetectorControl, DetectorTrigger
+from ophyd_async.epics.areadetector.drivers.ad_base import (
+    start_acquiring_driver_and_ensure_status,
+)
+from ophyd_async.epics.areadetector.drivers.pilatus_driver import (
+    PilatusDriver,
+    PilatusTriggerMode,
+)
+from ophyd_async.epics.areadetector.utils import ImageMode, stop_busy_record
+
+
+class PilatusController(DetectorControl):
+    _supported_trigger_types = {
+        DetectorTrigger.internal: PilatusTriggerMode.internal,
+        DetectorTrigger.constant_gate: PilatusTriggerMode.ext_enable,
+        DetectorTrigger.variable_gate: PilatusTriggerMode.ext_enable,
+    }
+
+    def __init__(
+        self,
+        driver: PilatusDriver,
+    ) -> None:
+        self._drv = driver
+
+    def get_deadtime(self, exposure: float) -> float:
+        # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+        """The required minimum time difference between ExpPeriod and ExpTime
+        (readout time) is 2.28 ms"""
+        return 2.28e-3
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        if exposure is not None:
+            await self._drv.acquire_time.set(exposure)
+        await asyncio.gather(
+            self._drv.trigger_mode.set(self._get_trigger_mode(trigger)),
+            self._drv.num_images.set(999_999 if num == 0 else num),
+            self._drv.image_mode.set(ImageMode.multiple),
+        )
+        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+    @classmethod
+    def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:
+        if trigger not in cls._supported_trigger_types.keys():
+            raise ValueError(
+                f"{cls.__name__} only supports the following trigger "
+                f"types: {cls._supported_trigger_types.keys()} but was asked to "
+                f"use {trigger}"
+            )
+        return cls._supported_trigger_types[trigger]
+
+    async def disarm(self):
+        await stop_busy_record(self._drv.acquire, False, timeout=1)