ophyd-async 0.3.2__tar.gz → 0.3.4a1__tar.gz

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3.2
+Version: 0.3.4a1
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.3.4a1'
+__version_tuple__ = version_tuple = (0, 3, 4)

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/core/__init__.py

@@ -50,7 +50,7 @@ from .signal import (
     soft_signal_rw,
     wait_for_value,
 )
-from .signal_backend import SignalBackend
+from .signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
 from .soft_signal_backend import SoftSignalBackend
 from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
 from .utils import (
@@ -68,66 +68,69 @@ from .utils import (
 )
 
 __all__ = [
-    "get_mock_put",
-    "callback_on_mock_put",
-    "mock_puts_blocked",
-    "set_mock_values",
-    "reset_mock_put_calls",
-    "SignalBackend",
-    "SoftSignalBackend",
+    "AsyncStatus",
+    "CalculatableTimeout",
+    "CalculateTimeout",
+    "Callback",
+    "ConfigSignal",
+    "DEFAULT_TIMEOUT",
     "DetectorControl",
-    "MockSignalBackend",
     "DetectorTrigger",
     "DetectorWriter",
-    "StandardDetector",
     "Device",
     "DeviceCollector",
     "DeviceVector",
-    "Signal",
-    "SignalR",
-    "SignalW",
-    "SignalRW",
-    "SignalX",
-    "soft_signal_r_and_setter",
-    "soft_signal_rw",
-    "observe_value",
-    "set_and_wait_for_value",
-    "set_mock_put_proceeds",
-    "set_mock_value",
-    "wait_for_value",
-    "AsyncStatus",
-    "WatchableAsyncStatus",
     "DirectoryInfo",
     "DirectoryProvider",
+    "HardwareTriggeredFlyable",
+    "HintedSignal",
+    "MockSignalBackend",
     "NameProvider",
+    "NotConnected",
+    "ReadingValueCallback",
+    "RuntimeSubsetEnum",
+    "SubsetEnum",
     "ShapeProvider",
-    "StaticDirectoryProvider",
+    "Signal",
+    "SignalBackend",
+    "SignalR",
+    "SignalRW",
+    "SignalW",
+    "SignalX",
+    "SoftSignalBackend",
+    "StandardDetector",
     "StandardReadable",
-    "ConfigSignal",
-    "HintedSignal",
+    "StaticDirectoryProvider",
+    "T",
     "TriggerInfo",
     "TriggerLogic",
-    "HardwareTriggeredFlyable",
-    "CalculateTimeout",
-    "CalculatableTimeout",
-    "DEFAULT_TIMEOUT",
-    "Callback",
-    "NotConnected",
-    "ReadingValueCallback",
-    "T",
+    "WatchableAsyncStatus",
+    "assert_configuration",
+    "assert_emitted",
+    "assert_mock_put_called_with",
+    "assert_reading",
+    "assert_value",
+    "callback_on_mock_put",
     "get_dtype",
-    "get_unique",
-    "merge_gathered_dicts",
-    "wait_for_connection",
+    "get_mock_put",
     "get_signal_values",
+    "get_unique",
+    "load_device",
     "load_from_yaml",
+    "merge_gathered_dicts",
+    "mock_puts_blocked",
+    "observe_value",
+    "reset_mock_put_calls",
+    "save_device",
     "save_to_yaml",
+    "set_and_wait_for_value",
+    "set_mock_put_proceeds",
+    "set_mock_value",
+    "set_mock_values",
     "set_signal_values",
+    "soft_signal_r_and_setter",
+    "soft_signal_rw",
+    "wait_for_connection",
+    "wait_for_value",
     "walk_rw_signals",
-    "load_device",
-    "save_device",
-    "assert_reading",
-    "assert_value",
-    "assert_configuration",
-    "assert_emitted",
 ]

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/core/signal_backend.py

@@ -1,5 +1,13 @@
 from abc import abstractmethod
-from typing import Generic, Optional, Type
+from typing import (
+    TYPE_CHECKING,
+    ClassVar,
+    Generic,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+)
 
 from bluesky.protocols import DataKey, Reading
 
@@ -45,3 +53,41 @@ class SignalBackend(Generic[T]):
     @abstractmethod
     def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
         """Observe changes to the current value, timestamp and severity"""
+
+
+class _RuntimeSubsetEnumMeta(type):
+    def __str__(cls):
+        if hasattr(cls, "choices"):
+            return f"SubsetEnum{list(cls.choices)}"
+        return "SubsetEnum"
+
+    def __getitem__(cls, _choices):
+        if isinstance(_choices, str):
+            _choices = (_choices,)
+        else:
+            if not isinstance(_choices, tuple) or not all(
+                isinstance(c, str) for c in _choices
+            ):
+                raise TypeError(
+                    "Choices must be a str or a tuple of str, " f"not {type(_choices)}."
+                )
+            if len(set(_choices)) != len(_choices):
+                raise TypeError("Duplicate elements in runtime enum choices.")
+
+        class _RuntimeSubsetEnum(cls):
+            choices = _choices
+
+        return _RuntimeSubsetEnum
+
+
+class RuntimeSubsetEnum(metaclass=_RuntimeSubsetEnumMeta):
+    choices: ClassVar[Tuple[str, ...]]
+
+    def __init__(self):
+        raise RuntimeError("SubsetEnum cannot be instantiated")
+
+
+if TYPE_CHECKING:
+    SubsetEnum = Literal
+else:
+    SubsetEnum = RuntimeSubsetEnum

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/core/soft_signal_backend.py

@@ -3,14 +3,23 @@ from __future__ import annotations
 import inspect
 import time
 from collections import abc
-from dataclasses import dataclass
 from enum import Enum
-from typing import Dict, Generic, Optional, Type, TypedDict, Union, cast, get_origin
+from typing import (
+    Dict,
+    Generic,
+    Optional,
+    Tuple,
+    Type,
+    TypedDict,
+    Union,
+    cast,
+    get_origin,
+)
 
 import numpy as np
 from bluesky.protocols import DataKey, Dtype, Reading
 
-from .signal_backend import SignalBackend
+from .signal_backend import RuntimeSubsetEnum, SignalBackend
 from .utils import DEFAULT_TIMEOUT, ReadingValueCallback, T, get_dtype
 
 primitive_dtypes: Dict[type, Dtype] = {
@@ -74,23 +83,27 @@ class SoftArrayConverter(SoftConverter):
         return cast(T, datatype(shape=0))  # type: ignore
 
 
-@dataclass
 class SoftEnumConverter(SoftConverter):
-    enum_class: Type[Enum]
+    choices: Tuple[str, ...]
 
-    def write_value(self, value: Union[Enum, str]) -> Enum:
+    def __init__(self, datatype: Union[RuntimeSubsetEnum, Enum]):
+        if issubclass(datatype, Enum):
+            self.choices = tuple(v.value for v in datatype)
+        else:
+            self.choices = datatype.choices
+
+    def write_value(self, value: Union[Enum, str]) -> str:
         if isinstance(value, Enum):
+            return value.value
+        else:  # Runtime enum
             return value
-        else:
-            return self.enum_class(value)
 
     def get_datakey(self, source: str, value, **metadata) -> DataKey:
-        choices = [e.value for e in self.enum_class]
         return {
             "source": source,
             "dtype": "string",
             "shape": [],
-            "choices": choices,
+            "choices": self.choices,
             **metadata,
         }
 
@@ -98,13 +111,17 @@ class SoftEnumConverter(SoftConverter):
         if datatype is None:
             return cast(T, None)
 
-        return cast(T, list(datatype.__members__.values())[0])  # type: ignore
+        if issubclass(datatype, Enum):
+            return cast(T, list(datatype.__members__.values())[0])  # type: ignore
+        return cast(T, self.choices[0])
 
 
 def make_converter(datatype):
     is_array = get_dtype(datatype) is not None
     is_sequence = get_origin(datatype) == abc.Sequence
-    is_enum = issubclass(datatype, Enum) if inspect.isclass(datatype) else False
+    is_enum = inspect.isclass(datatype) and (
+        issubclass(datatype, Enum) or issubclass(datatype, RuntimeSubsetEnum)
+    )
 
     if is_array or is_sequence:
         return SoftArrayConverter()

ophyd_async-0.3.4a1/src/ophyd_async/epics/_backend/common.py

@@ -0,0 +1,62 @@
+import inspect
+from enum import Enum
+from typing import Dict, Optional, Tuple, Type, TypedDict
+
+from ophyd_async.core.signal_backend import RuntimeSubsetEnum
+
+common_meta = {
+    "units",
+    "precision",
+}
+
+
+class LimitPair(TypedDict):
+    high: float | None
+    low: float | None
+
+    def __bool__(self) -> bool:
+        return self.low is None and self.high is None
+
+
+class Limits(TypedDict):
+    alarm: LimitPair
+    control: LimitPair
+    display: LimitPair
+    warning: LimitPair
+
+    def __bool__(self) -> bool:
+        return any(self.alarm, self.control, self.display, self.warning)
+
+
+def get_supported_values(
+    pv: str,
+    datatype: Optional[Type[str]],
+    pv_choices: Tuple[str, ...],
+) -> Dict[str, str]:
+    if inspect.isclass(datatype) and issubclass(datatype, RuntimeSubsetEnum):
+        if not set(datatype.choices).issubset(set(pv_choices)):
+            raise TypeError(
+                f"{pv} has choices {pv_choices}, "
+                f"which is not a superset of {str(datatype)}."
+            )
+        return {x: x or "_" for x in pv_choices}
+    elif inspect.isclass(datatype) and issubclass(datatype, Enum):
+        if not issubclass(datatype, str):
+            raise TypeError(
+                f"{pv} is type Enum but {datatype} does not inherit from String."
+            )
+
+        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) if x else "_" for x in pv_choices}
+    elif datatype is None:
+        return {x: x or "_" for x in pv_choices}
+
+    raise TypeError(
+        f"{pv} has choices {pv_choices}. "
+        "Use an Enum or SubsetEnum to represent this."
+    )

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -5,6 +5,7 @@ from ophyd_async.core import DEFAULT_TIMEOUT, wait_for_value
 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 (
+    set_exposure_time_and_acquire_period_if_supplied,
     start_acquiring_driver_and_ensure_status,
 )
 from ophyd_async.epics.areadetector.drivers.pilatus_driver import (
@@ -39,7 +40,9 @@ class PilatusController(DetectorControl):
         exposure: Optional[float] = None,
     ) -> AsyncStatus:
         if exposure is not None:
-            await self._drv.acquire_time.set(exposure)
+            await set_exposure_time_and_acquire_period_if_supplied(
+                self, self._drv, 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),

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/epics/areadetector/drivers/__init__.py

@@ -2,6 +2,7 @@ from .ad_base import (
     ADBase,
     ADBaseShapeProvider,
     DetectorState,
+    set_exposure_time_and_acquire_period_if_supplied,
     start_acquiring_driver_and_ensure_status,
 )
 from .aravis_driver import AravisDriver
@@ -17,5 +18,6 @@ __all__ = [
     "KinetixDriver",
     "VimbaDriver",
     "start_acquiring_driver_and_ensure_status",
+    "set_exposure_time_and_acquire_period_if_supplied",
     "DetectorState",
 ]

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/epics/areadetector/drivers/ad_base.py

@@ -5,6 +5,7 @@ from typing import FrozenSet, Sequence, Set
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DetectorControl,
     ShapeProvider,
     set_and_wait_for_value,
 )
@@ -44,6 +45,7 @@ class ADBase(NDArrayBase):
     def __init__(self, prefix: str, name: str = "") -> None:
         # Define some signals
         self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
+        self.acquire_period = epics_signal_rw_rbv(float, prefix + "AcquirePeriod")
         self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
         self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
         self.detector_state = epics_signal_r(
@@ -52,6 +54,36 @@ class ADBase(NDArrayBase):
         super().__init__(prefix, name=name)
 
 
+async def set_exposure_time_and_acquire_period_if_supplied(
+    controller: DetectorControl,
+    driver: ADBase,
+    exposure: float | None = None,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> None:
+    """
+    Sets the exposure time if it is not None and the acquire period to the
+    exposure time plus the deadtime. This is expected behavior for most
+    AreaDetectors, but some may require more specialized handling.
+
+    Parameters
+    ----------
+    controller:
+        Controller that can supply a deadtime.
+    driver:
+        The driver to start acquiring. Must subclass ADBase.
+    exposure:
+        Desired exposure time, this is a noop if it is None.
+    timeout:
+        How long to wait for the exposure time and acquire period to be set.
+    """
+    if exposure is not None:
+        full_frame_time = exposure + controller.get_deadtime(exposure)
+        await asyncio.gather(
+            driver.acquire_time.set(exposure, timeout=timeout),
+            driver.acquire_period.set(full_frame_time, timeout=timeout),
+        )
+
+
 async def start_acquiring_driver_and_ensure_status(
     driver: ADBase,
     good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES),

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/epics/areadetector/drivers/aravis_driver.py

@@ -1,6 +1,6 @@
 from enum import Enum
-from typing import Literal
 
+from ophyd_async.core import SubsetEnum
 from ophyd_async.epics.areadetector.drivers import ADBase
 from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
 
@@ -19,7 +19,7 @@ class AravisTriggerMode(str, Enum):
     To prevent requiring one Enum class per possible configuration, we set as this Enum
     but read from the underlying signal as a str.
     """
-AravisTriggerSource = Literal["Freerun", "Line1", "Line2", "Line3", "Line4"]
+AravisTriggerSource = SubsetEnum["Freerun", "Line1"]
 
 
 class AravisDriver(ADBase):
@@ -34,5 +34,7 @@ class AravisDriver(ADBase):
         self.trigger_mode = epics_signal_rw_rbv(
             AravisTriggerMode, prefix + "TriggerMode"
         )
-        self.trigger_source = epics_signal_rw_rbv(str, prefix + "TriggerSource")
+        self.trigger_source = epics_signal_rw_rbv(
+            AravisTriggerSource, prefix + "TriggerSource"
+        )
         super().__init__(prefix, name=name)

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async/epics/motion/motor.py

@@ -95,5 +95,3 @@ class Motor(StandardReadable, Movable, Stoppable):
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
         await self.motor_stop.trigger(wait=False)
-        # Trigger any callbacks
-        await self.user_readback._backend.put(await self.user_readback.get_value())

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3.2
+Version: 0.3.4a1
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/src/ophyd_async.egg-info/SOURCES.txt

@@ -156,6 +156,7 @@ tests/core/test_mock_signal_backend.py
 tests/core/test_signal.py
 tests/core/test_soft_signal_backend.py
 tests/core/test_standard_readable.py
+tests/core/test_subset_enum.py
 tests/core/test_utils.py
 tests/core/test_watchable_async_status.py
 tests/epics/test_pvi.py

{ophyd_async-0.3.2 → ophyd_async-0.3.4a1}/tests/core/test_soft_signal_backend.py

@@ -31,7 +31,7 @@ def string_d(value):
 
 
 def enum_d(value):
-    return {"dtype": "string", "shape": [], "choices": ["Aaa", "Bbb", "Ccc"]}
+    return {"dtype": "string", "shape": [], "choices": ("Aaa", "Bbb", "Ccc")}
 
 
 def waveform_d(value):

ophyd_async-0.3.4a1/tests/core/test_subset_enum.py

@@ -0,0 +1,90 @@
+import pytest
+from epicscorelibs.ca import dbr
+from p4p import Value as P4PValue
+from p4p.nt import NTEnum
+
+from ophyd_async.core import SubsetEnum
+from ophyd_async.epics._backend._aioca import make_converter as aioca_make_converter
+from ophyd_async.epics._backend._p4p import make_converter as p4p_make_converter
+from ophyd_async.epics.signal.signal import epics_signal_rw
+
+
+async def test_runtime_enum_behaviour():
+    rt_enum = SubsetEnum["A", "B"]
+
+    with pytest.raises(RuntimeError) as exc:
+        rt_enum()
+    assert str(exc.value) == "SubsetEnum cannot be instantiated"
+
+    assert issubclass(rt_enum, SubsetEnum)
+
+    # Our metaclass doesn't cache already created runtime enums,
+    # so we can't do this
+    assert not issubclass(rt_enum, SubsetEnum["A", "B"])
+    assert not issubclass(rt_enum, SubsetEnum["B", "A"])
+    assert rt_enum is not SubsetEnum["A", "B"]
+    assert rt_enum is not SubsetEnum["B", "A"]
+
+    assert str(rt_enum) == "SubsetEnum['A', 'B']"
+    assert str(SubsetEnum) == "SubsetEnum"
+
+    with pytest.raises(TypeError) as exc:
+        SubsetEnum["A", "B", "A"]
+    assert str(exc.value) == "Duplicate elements in runtime enum choices."
+
+
+async def test_ca_runtime_enum_converter():
+    class EpicsValue:
+        def __init__(self):
+            self.name = "test"
+            self.ok = (True,)
+            self.errorcode = 0
+            self.datatype = dbr.DBR_ENUM
+            self.element_count = 1
+            self.severity = 0
+            self.status = 0
+            self.raw_stamp = (0,)
+            self.timestamp = 0
+            self.datetime = 0
+            self.enums = ["A", "B", "C"]  # More than the runtime enum
+
+    epics_value = EpicsValue()
+    rt_enum = SubsetEnum["A", "B"]
+    converter = aioca_make_converter(
+        rt_enum, values={"READ_PV": epics_value, "WRITE_PV": epics_value}
+    )
+    assert converter.choices == {"A": "A", "B": "B", "C": "C"}
+    assert set(rt_enum.choices).issubset(set(converter.choices.keys()))
+
+
+async def test_pva_runtime_enum_converter():
+    enum_type = NTEnum.buildType()
+    epics_value = P4PValue(
+        enum_type,
+        {
+            "value.choices": ["A", "B", "C"],
+        },
+    )
+    rt_enum = SubsetEnum["A", "B"]
+    converter = p4p_make_converter(
+        rt_enum, values={"READ_PV": epics_value, "WRITE_PV": epics_value}
+    )
+    assert {"A", "B"}.issubset(set(converter.choices))
+
+
+async def test_runtime_enum_signal():
+    signal_rw_pva = epics_signal_rw(SubsetEnum["A1", "B1"], "ca://RW_PV", name="signal")
+    signal_rw_ca = epics_signal_rw(SubsetEnum["A2", "B2"], "ca://RW_PV", name="signal")
+    await signal_rw_pva.connect(mock=True)
+    await signal_rw_ca.connect(mock=True)
+    await signal_rw_pva.get_value() == "A1"
+    await signal_rw_ca.get_value() == "A2"
+    await signal_rw_pva.set("B1")
+    await signal_rw_ca.set("B2")
+    await signal_rw_pva.get_value() == "B1"
+    await signal_rw_ca.get_value() == "B2"
+
+    # Will accept string values even if they're not in the runtime enum
+    # Though type checking should compain
+    await signal_rw_pva.set("C1")  # type: ignore
+    await signal_rw_ca.set("C2")  # type: ignore

ophyd_async-0.3.4a1/tests/epics/areadetector/test_drivers.py

@@ -0,0 +1,96 @@
+import asyncio
+from unittest.mock import Mock
+
+import pytest
+
+from ophyd_async.core import (
+    DetectorControl,
+    DeviceCollector,
+    get_mock_put,
+    set_mock_value,
+)
+from ophyd_async.epics.areadetector.drivers import (
+    ADBase,
+    DetectorState,
+    set_exposure_time_and_acquire_period_if_supplied,
+    start_acquiring_driver_and_ensure_status,
+)
+
+TEST_DEADTIME = 0.1
+
+
+@pytest.fixture
+def driver(RE) -> ADBase:
+    with DeviceCollector(mock=True):
+        driver = ADBase("DRV:", name="drv")
+    return driver
+
+
+@pytest.fixture
+async def controller(RE, driver: ADBase) -> Mock:
+    controller = Mock(spec=DetectorControl)
+    controller.get_deadtime.return_value = TEST_DEADTIME
+    return controller
+
+
+async def test_set_exposure_time_and_acquire_period_if_supplied_is_a_noop_if_no_exposure_supplied(  # noqa: E501
+    controller: DetectorControl,
+    driver: ADBase,
+):
+    put_exposure = get_mock_put(driver.acquire_time)
+    put_acquire_period = get_mock_put(driver.acquire_period)
+    await set_exposure_time_and_acquire_period_if_supplied(controller, driver, None)
+    put_exposure.assert_not_called()
+    put_acquire_period.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    "exposure,expected_exposure,expected_acquire_period",
+    [
+        (0.0, 0.0, 0.1),
+        (1.0, 1.0, 1.1),
+        (1.5, 1.5, 1.6),
+    ],
+)
+async def test_set_exposure_time_and_acquire_period_if_supplied_uses_deadtime(
+    controller: DetectorControl,
+    driver: ADBase,
+    exposure: float,
+    expected_exposure: float,
+    expected_acquire_period: float,
+):
+    await set_exposure_time_and_acquire_period_if_supplied(controller, driver, exposure)
+    actual_exposure = await driver.acquire_time.get_value()
+    actual_acquire_period = await driver.acquire_period.get_value()
+    assert expected_exposure == actual_exposure
+    assert expected_acquire_period == actual_acquire_period
+
+
+async def test_start_acquiring_driver_and_ensure_status_flags_immediate_failure(
+    driver: ADBase,
+):
+    set_mock_value(driver.detector_state, DetectorState.Error)
+    acquiring = await start_acquiring_driver_and_ensure_status(driver, timeout=0.01)
+    with pytest.raises(ValueError):
+        await acquiring
+
+
+async def test_start_acquiring_driver_and_ensure_status_fails_after_some_time(
+    driver: ADBase,
+):
+    """This test ensures a failing status is captured halfway through acquisition.
+
+    Real world application; it takes some time to start acquiring, and during that time
+    the detector gets itself into a bad state.
+    """
+    set_mock_value(driver.detector_state, DetectorState.Idle)
+
+    async def wait_then_fail():
+        await asyncio.sleep(0)
+        set_mock_value(driver.detector_state, DetectorState.Disconnected)
+
+    acquiring = await start_acquiring_driver_and_ensure_status(driver, timeout=0.1)
+    await wait_then_fail()
+
+    with pytest.raises(ValueError):
+        await acquiring