ophyd-async 0.10.0a3__tar.gz → 0.10.1__tar.gz

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a3
+Version: 0.10.1
 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
@@ -43,7 +43,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: bluesky>=1.13.1rc2
-Requires-Dist: event-model>=1.22.1
+Requires-Dist: event-model>=1.23
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/pyproject.toml

@@ -15,7 +15,7 @@ description = "Asynchronous Bluesky hardware abstraction code, compatible with c
 dependencies = [
     "numpy",
     "bluesky>=1.13.1rc2",
-    "event-model>=1.22.1",
+    "event-model>=1.23",
     "pyyaml",
     "colorlog",
     "pydantic>=2.0",
@@ -134,7 +134,6 @@ commands =
 """
 
 [tool.ruff]
-src = ["src", "tests", "system_tests"]
 line-length = 88
 lint.select = [
     "B",       # flake8-bugbear - https://docs.astral.sh/ruff/rules/#flake8-bugbear-b

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.10.0a3'
-__version_tuple__ = version_tuple = (0, 10, 0, 'a3')
+__version__ = version = '0.10.1'
+__version_tuple__ = version_tuple = (0, 10, 1)

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/__init__.py

@@ -75,11 +75,13 @@ from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     Callback,
+    EnumTypes,
     LazyMock,
     NotConnected,
     Reference,
     StrictEnum,
     SubsetEnum,
+    SupersetEnum,
     WatcherUpdate,
     gather_dict,
     get_dtype,
@@ -122,6 +124,8 @@ __all__ = [
     "Array1D",
     "StrictEnum",
     "SubsetEnum",
+    "SupersetEnum",
+    "EnumTypes",
     "Table",
     "SignalMetadata",
     # Soft signal

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/_derived_signal.py

@@ -1,5 +1,7 @@
 from collections.abc import Awaitable, Callable
-from typing import Any, Generic, get_type_hints, is_typeddict
+from typing import Any, Generic, get_args, get_origin, get_type_hints, is_typeddict
+
+from bluesky.protocols import Locatable
 
 from ._derived_signal_backend import (
     DerivedSignalBackend,
@@ -8,7 +10,7 @@ from ._derived_signal_backend import (
     TransformT,
 )
 from ._device import Device
-from ._signal import SignalR, SignalRW, SignalT, SignalW
+from ._signal import Signal, SignalR, SignalRW, SignalT, SignalW
 from ._signal_backend import SignalDatatypeT
 
 
@@ -35,15 +37,27 @@ class DerivedSignalFactory(Generic[TransformT]):
         self._set_derived = set_derived
         # Check the raw and transform devices match the input arguments of the Transform
         if transform_cls is not Transform:
-            expected = list(transform_cls.model_fields) + [
-                x
-                for x in get_type_hints(transform_cls.raw_to_derived)
-                if x not in ["self", "return"]
-            ]
-            if set(expected) != set(raw_and_transform_devices):
+            # Populate expected parameters and types
+            expected = {
+                **{k: f.annotation for k, f in transform_cls.model_fields.items()},
+                **{
+                    k: v
+                    for k, v in get_type_hints(transform_cls.raw_to_derived).items()
+                    if k not in {"self", "return"}
+                },
+            }
+
+            # Populate received parameters and types
+            # Use Signal datatype, or Locatable datatype, or set type as None
+            received = {
+                k: v.datatype if isinstance(v, Signal) else get_locatable_type(v)
+                for k, v in raw_and_transform_devices.items()
+            }
+
+            if expected != received:
                 msg = (
-                    f"Expected devices to be passed as keyword arguments {expected}, "
-                    f"got {list(raw_and_transform_devices)}"
+                    f"Expected devices to be passed as keyword arguments "
+                    f"{expected}, got {received}"
                 )
                 raise TypeError(msg)
         self._set_derived_takes_dict = (
@@ -234,7 +248,7 @@ def derived_signal_rw(
     if raw_to_derived_datatype != set_derived_datatype:
         msg = (
             f"{raw_to_derived} has datatype {raw_to_derived_datatype} "
-            f"!= {set_derived_datatype} dataype {set_derived_datatype}"
+            f"!= {set_derived_datatype} datatype {set_derived_datatype}"
         )
         raise TypeError(msg)
 
@@ -269,3 +283,17 @@ def derived_signal_w(
         units=derived_units,
         precision=derived_precision,
     )
+
+
+def get_locatable_type(obj: object) -> type | None:
+    """Extract datatype from Locatable parent class.
+
+    :param obj: Object with possible Locatable inheritance
+    :return: Type hint associated with Locatable, or None if not found.
+    """
+    for base in getattr(obj.__class__, "__orig_bases__", []):
+        if get_origin(base) is Locatable:
+            args = get_args(base)
+            if args:
+                return args[0]
+    return None

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/_derived_signal_backend.py

@@ -61,7 +61,7 @@ class Transform(BaseModel, Generic[RawT, DerivedT]):
 TransformT = TypeVar("TransformT", bound=Transform)
 
 
-def filter_by_type(raw_devices: Mapping[str, Any], type_: type[T]) -> dict[str, T]:
+def validate_by_type(raw_devices: Mapping[str, Any], type_: type[T]) -> dict[str, T]:
     filtered_devices: dict[str, T] = {}
     for name, device in raw_devices.items():
         if not isinstance(device, type_):
@@ -91,21 +91,23 @@ class SignalTransformer(Generic[TransformT]):
 
     @cached_property
     def raw_locatables(self) -> dict[str, AsyncLocatable]:
-        return filter_by_type(self._raw_devices, AsyncLocatable)
+        return validate_by_type(self._raw_devices, AsyncLocatable)
 
     @cached_property
     def transform_readables(self) -> dict[str, AsyncReadable]:
-        return filter_by_type(self._transform_devices, AsyncReadable)
+        return validate_by_type(self._transform_devices, AsyncReadable)
 
     @cached_property
     def raw_and_transform_readables(self) -> dict[str, AsyncReadable]:
-        return filter_by_type(
+        return validate_by_type(
             self._raw_devices | self._transform_devices, AsyncReadable
         )
 
     @cached_property
     def raw_and_transform_subscribables(self) -> dict[str, Subscribable]:
-        return filter_by_type(self._raw_devices | self._transform_devices, Subscribable)
+        return validate_by_type(
+            self._raw_devices | self._transform_devices, Subscribable
+        )
 
     def _complete_cached_reading(self) -> dict[str, Reading] | None:
         if self._cached_readings and len(self._cached_readings) == len(

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/_detector.py

@@ -328,10 +328,10 @@ class StandardDetector(
             if isinstance(value.number_of_events, list)
             else [value.number_of_events]
         )
-        self._describe, _ = await asyncio.gather(
-            self._writer.open(self.name, value.exposures_per_event),
-            self._controller.prepare(value),
-        )
+
+        await self._controller.prepare(value)
+        self._describe = await self._writer.open(self.name, value.exposures_per_event)
+
         self._initial_frame = await self._writer.get_indices_written()
         if value.trigger != DetectorTrigger.INTERNAL:
             await self._controller.arm()

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/_hdf_dataset.py

@@ -23,7 +23,7 @@ class HDFDatasetDescription(BaseModel):
     """The dataset name within the HDF file,
     e.g. /entry/data/data or /entry/instrument/NDAttributes/sum"""
 
-    shape: tuple[int, ...] = Field(default_factory=tuple)
+    shape: tuple[int | None, ...] = Field(default_factory=tuple)
     """The shape of a single event's data in the HDF file,
     e.g. (1, 768, 1024) for arrays or () for scalars"""
 

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/_providers.py

@@ -228,5 +228,5 @@ class DatasetDescriber(Protocol):
         """Return the numpy datatype for this dataset."""
 
     @abstractmethod
-    async def shape(self) -> tuple[int, ...]:
+    async def shape(self) -> tuple[int | None, ...]:
         """Get the shape of the data collection."""

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/_signal.py

@@ -100,6 +100,11 @@ class Signal(Device, Generic[SignalDatatypeT]):
         """
         return self._connector.backend.source(self.name, read=True)
 
+    @property
+    def datatype(self) -> type[SignalDatatypeT] | None:
+        """Returns the datatype of the signal."""
+        return self._connector.backend.datatype
+
 
 SignalT = TypeVar("SignalT", bound=Signal)
 
@@ -158,7 +163,12 @@ class _SignalCache(Generic[SignalDatatypeT]):
             self._notify(function, want_value)
 
     def unsubscribe(self, function: Callback) -> bool:
-        self._listeners.pop(function)
+        _listener = self._listeners.pop(function, None)
+        if not _listener:
+            self._signal.log.warning(
+                f"Unsubscribe failed: subscriber {function} was not found "
+                f" in listeners list: {list(self._listeners)}"
+            )
         return self._staged or bool(self._listeners)
 
     def set_staged(self, staged: bool) -> bool:
@@ -431,8 +441,8 @@ async def observe_signals_value(
         Call subscribe_value on all the signals at the start, and clear_sub on
         it at the end.
     :param timeout:
-        If given, how long to wait for each updated value in seconds. If an
-        update is not produced in this time then raise asyncio.TimeoutError.
+        If given, how long to wait for ANY updated value from shared queue in seconds.
+        If an update is not produced in this time then raise asyncio.TimeoutError.
     :param done_status:
         If this status is complete, stop observing and make the iterator return.
         If it raises an exception then this exception will be raised by the
@@ -454,8 +464,10 @@ async def observe_signals_value(
     q: asyncio.Queue[tuple[SignalR[SignalDatatypeT], SignalDatatypeT] | Status] = (
         asyncio.Queue()
     )
-
+    # dict to store signal subscription to remove it later
     cbs: dict[SignalR, Callback] = {}
+
+    # subscribe signal to update queue and fill cbs dict
     for signal in signals:
 
         def queue_value(value: SignalDatatypeT, signal=signal):
@@ -468,6 +480,7 @@ async def observe_signals_value(
         done_status.add_callback(q.put_nowait)
     overall_deadline = time.monotonic() + done_timeout if done_timeout else None
     try:
+        last_item = ()
         while True:
             if overall_deadline and time.monotonic() >= overall_deadline:
                 raise asyncio.TimeoutError(
@@ -476,14 +489,22 @@ async def observe_signals_value(
                     f"timeout {done_timeout}s"
                 )
             iteration_timeout = _get_iteration_timeout(timeout, overall_deadline)
-            item = await asyncio.wait_for(q.get(), iteration_timeout)
+            try:
+                item = await asyncio.wait_for(q.get(), iteration_timeout)
+            except asyncio.TimeoutError as exc:
+                raise asyncio.TimeoutError(
+                    f"Timeout Error while waiting {iteration_timeout}s to update "
+                    f"{[signal.source for signal in signals]}. "
+                    f"Last observed signal and value were {last_item}"
+                ) from exc
             if done_status and item is done_status:
                 if exc := done_status.exception():
                     raise exc
                 else:
                     break
             else:
-                yield cast(tuple[SignalR[SignalDatatypeT], SignalDatatypeT], item)
+                last_item = cast(tuple[SignalR[SignalDatatypeT], SignalDatatypeT], item)
+                yield last_item
     finally:
         for signal, cb in cbs.items():
             signal.clear_sub(cb)

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/_signal_backend.py

@@ -6,8 +6,16 @@ import numpy as np
 from bluesky.protocols import Reading
 from event_model import DataKey, Dtype, Limits
 
+from ophyd_async.core._utils import (
+    Callback,
+    EnumTypes,
+    StrictEnum,
+    SubsetEnum,
+    SupersetEnum,
+    get_enum_cls,
+)
+
 from ._table import Table
-from ._utils import Callback, StrictEnum, get_enum_cls
 
 DTypeScalar_co = TypeVar("DTypeScalar_co", covariant=True, bound=np.generic)
 """A numpy dtype like [](#numpy.float64)."""
@@ -24,7 +32,7 @@ E.g. `Array1D[np.float64]` is a 1D numpy array of 64-bit floats."""
 Primitive = bool | int | float | str
 SignalDatatype = (
     Primitive
-    | StrictEnum
+    | EnumTypes
     | Array1D[np.bool_]
     | Array1D[np.int8]
     | Array1D[np.uint8]
@@ -39,16 +47,18 @@ SignalDatatype = (
     | np.ndarray
     | Sequence[str]
     | Sequence[StrictEnum]
+    | Sequence[SubsetEnum]
+    | Sequence[SupersetEnum]
     | Table
 )
 """The supported [](#Signal) datatypes:
 
 - A python primitive [](#bool), [](#int), [](#float), [](#str)
-- A [](#StrictEnum) or [](#SubsetEnum) subclass
+- An [](#EnumTypes) subclass
 - A fixed datatype [](#Array1D) of numpy bool, signed and unsigned integers or float
 - A [](#numpy.ndarray) which can change dimensions and datatype at runtime
 - A sequence of [](#str)
-- A sequence of [](#StrictEnum) or [](#SubsetEnum) subclass
+- A sequence of [](#EnumTypes) subclasses
 - A [](#Table) subclass
 """
 # TODO: These typevars will not be needed when we drop python 3.11
@@ -58,7 +68,7 @@ PrimitiveT = TypeVar("PrimitiveT", bound=Primitive)
 SignalDatatypeT = TypeVar("SignalDatatypeT", bound=SignalDatatype)
 """A typevar for a [](#SignalDatatype)."""
 SignalDatatypeV = TypeVar("SignalDatatypeV", bound=SignalDatatype)
-EnumT = TypeVar("EnumT", bound=StrictEnum)
+EnumT = TypeVar("EnumT", bound=EnumTypes)
 TableT = TypeVar("TableT", bound=Table)
 
 
@@ -136,7 +146,7 @@ def _datakey_dtype(datatype: type[SignalDatatype]) -> Dtype:
         or issubclass(datatype, Table)
     ):
         return "array"
-    elif issubclass(datatype, StrictEnum):
+    elif issubclass(datatype, EnumTypes):
         return "string"
     elif issubclass(datatype, Primitive):
         return _primitive_dtype[datatype]
@@ -153,7 +163,7 @@ def _datakey_dtype_numpy(
     elif (
         get_origin(datatype) is Sequence
         or datatype is str
-        or issubclass(datatype, StrictEnum)
+        or issubclass(datatype, EnumTypes)
     ):
         # TODO: use np.dtypes.StringDType when we can use in structured arrays
         # https://github.com/numpy/numpy/issues/25693
@@ -166,8 +176,8 @@ def _datakey_dtype_numpy(
         raise TypeError(f"Can't make dtype_numpy for {datatype}")
 
 
-def _datakey_shape(value: SignalDatatype) -> list[int]:
-    if type(value) in _primitive_dtype or isinstance(value, StrictEnum):
+def _datakey_shape(value: SignalDatatype) -> list[int | None]:
+    if type(value) in _primitive_dtype or isinstance(value, EnumTypes):
         return []
     elif isinstance(value, np.ndarray):
         return list(value.shape)

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/core/_utils.py

@@ -5,7 +5,15 @@ import logging
 from collections.abc import Awaitable, Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum, EnumMeta
-from typing import Any, Generic, Literal, ParamSpec, TypeVar, get_args, get_origin
+from typing import (
+    Any,
+    Generic,
+    Literal,
+    ParamSpec,
+    TypeVar,
+    get_args,
+    get_origin,
+)
 from unittest.mock import Mock
 
 import numpy as np
@@ -19,20 +27,16 @@ DEFAULT_TIMEOUT = 10.0
 logger = logging.getLogger("ophyd_async")
 
 
-class StrictEnumMeta(EnumMeta):
-    def __new__(metacls, *args, **kwargs):
-        ret = super().__new__(metacls, *args, **kwargs)
+class UppercaseNameEnumMeta(EnumMeta):
+    def __new__(cls, *args, **kwargs):
+        ret = super().__new__(cls, *args, **kwargs)
         lowercase_names = [x.name for x in ret if not x.name.isupper()]  # type: ignore
         if lowercase_names:
             raise TypeError(f"Names {lowercase_names} should be uppercase")
         return ret
 
 
-class StrictEnum(str, Enum, metaclass=StrictEnumMeta):
-    """All members should exist in the Backend, and there will be no extras."""
-
-
-class SubsetEnumMeta(StrictEnumMeta):
+class AnyStringUppercaseNameEnumMeta(UppercaseNameEnumMeta):
     def __call__(self, value, *args, **kwargs):  # type: ignore
         """Return given value if it is a string and not a member of the enum.
 
@@ -54,10 +58,21 @@ class SubsetEnumMeta(StrictEnumMeta):
         return super().__call__(value, *args, **kwargs)
 
 
-class SubsetEnum(StrictEnum, metaclass=SubsetEnumMeta):
+class StrictEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+    """All members should exist in the Backend, and there will be no extras."""
+
+
+class SubsetEnum(str, Enum, metaclass=AnyStringUppercaseNameEnumMeta):
     """All members should exist in the Backend, but there may be extras."""
 
 
+class SupersetEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+    """Some members should exist in the Backend, and there should be no extras."""
+
+
+EnumTypes = StrictEnum | SubsetEnum | SupersetEnum
+
+
 CALCULATE_TIMEOUT = "CALCULATE_TIMEOUT"
 """Sentinel used to implement ``myfunc(timeout=CalculateTimeout)``
 
@@ -207,10 +222,11 @@ def get_dtype(datatype: type) -> np.dtype:
     return np.dtype(get_args(get_args(datatype)[1])[0])
 
 
-def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
+def get_enum_cls(datatype: type | None) -> type[EnumTypes] | None:
     """Get the enum class from a datatype.
 
-    :raises TypeError: if type is not a [](#StrictEnum) or [](#SubsetEnum) subclass
+    :raises TypeError: if type is not a [](#StrictEnum) or [](#SubsetEnum)
+    or [](#SupersetEnum) subclass
     ```python
     >>> from ophyd_async.core import StrictEnum
     >>> from collections.abc import Sequence
@@ -227,10 +243,11 @@ def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
     if get_origin(datatype) is Sequence:
         datatype = get_args(datatype)[0]
     if datatype and issubclass(datatype, Enum):
-        if not issubclass(datatype, StrictEnum):
+        if not issubclass(datatype, EnumTypes):
             raise TypeError(
                 f"{datatype} should inherit from ophyd_async.core.SubsetEnum "
-                "or ophyd_async.core.StrictEnum"
+                "or ophyd_async.core.StrictEnum "
+                "or ophyd_async.core.SupersetEnum."
             )
         return datatype
     return None

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/epics/adcore/_core_detector.py

@@ -22,8 +22,8 @@ class AreaDetector(StandardDetector[ADBaseControllerT, ADWriter]):
         self.fileio = writer.fileio
 
         if plugins is not None:
-            for name, plugin in plugins.items():
-                setattr(self, name, plugin)
+            for plugin_name, plugin in plugins.items():
+                setattr(self, plugin_name, plugin)
 
         super().__init__(
             controller,

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/epics/adcore/_core_io.py

@@ -70,14 +70,14 @@ class NDPluginStatsIO(NDPluginBaseIO):
     # Basic statistics
     compute_statistics: A[SignalRW[bool], PvSuffix.rbv("ComputeStatistics")]
     bgd_width: A[SignalRW[int], PvSuffix.rbv("BgdWidth")]
-    total_array: A[SignalRW[float], PvSuffix.rbv("TotalArray")]
+    total: A[SignalR[float], PvSuffix.rbv("Total")]
     # Centroid statistics
     compute_centroid: A[SignalRW[bool], PvSuffix.rbv("ComputeCentroid")]
     centroid_threshold: A[SignalRW[float], PvSuffix.rbv("CentroidThreshold")]
     # X and Y Profiles
     compute_profiles: A[SignalRW[bool], PvSuffix.rbv("ComputeProfiles")]
-    profile_size_x: A[SignalRW[int], PvSuffix.rbv("ProfileSizeX")]
-    profile_size_y: A[SignalRW[int], PvSuffix.rbv("ProfileSizeY")]
+    profile_size_x: A[SignalR[int], PvSuffix.rbv("ProfileSizeX")]
+    profile_size_y: A[SignalR[int], PvSuffix.rbv("ProfileSizeY")]
     cursor_x: A[SignalRW[int], PvSuffix.rbv("CursorX")]
     cursor_y: A[SignalRW[int], PvSuffix.rbv("CursorY")]
     # Array Histogram

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/epics/adcore/_core_logic.py

@@ -7,6 +7,7 @@ from ophyd_async.core import (
     DetectorController,
     DetectorTrigger,
     TriggerInfo,
+    observe_value,
     set_and_wait_for_value,
 )
 
@@ -89,34 +90,57 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                 self.driver.acquire_period.set(full_frame_time, timeout=timeout),
             )
 
-    async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
+    async def start_acquiring_driver_and_ensure_status(
+        self,
+        start_timeout: float = DEFAULT_TIMEOUT,
+        state_timeout: float = DEFAULT_TIMEOUT,
+    ) -> AsyncStatus:
         """Start acquiring driver, raising ValueError if the detector is in a bad state.
 
         This sets driver.acquire to True, and waits for it to be True up to a timeout.
         Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES,
         and otherwise raises a ValueError.
 
+
+        :param start_timeout:
+            Timeout used for waiting for the driver to start
+            acquiring.
+        :param state_timeout:
+            Timeout used for waiting for the detector to be in a good
+            state after it stops acquiring.
         :returns AsyncStatus:
             An AsyncStatus that can be awaited to set driver.acquire to True and perform
             subsequent raising (if applicable) due to detector state.
+
         """
         status = await set_and_wait_for_value(
             self.driver.acquire,
             True,
-            timeout=DEFAULT_TIMEOUT,
+            timeout=start_timeout,
             wait_for_set_completion=False,
         )
 
         async def complete_acquisition() -> None:
-            # NOTE: possible race condition here between the callback from
-            # set_and_wait_for_value and the detector state updating.
             await status
-            state = await self.driver.detector_state.get_value()
-            if state not in self.good_states:
-                raise ValueError(
-                    f"Final detector state {state.value} not "
-                    "in valid end states: {self.good_states}"
-                )
+            state = None
+            try:
+                async for state in observe_value(
+                    self.driver.detector_state, done_timeout=state_timeout
+                ):
+                    if state in self.good_states:
+                        return
+            except asyncio.TimeoutError as exc:
+                if state is not None:
+                    raise ValueError(
+                        f"Final detector state {state.value} not in valid end "
+                        f"states: {self.good_states}"
+                    ) from exc
+                else:
+                    # No updates from the detector, something else is wrong
+                    raise asyncio.TimeoutError(
+                        "Could not monitor detector state: "
+                        + self.driver.detector_state.source
+                    ) from exc
 
         return AsyncStatus(complete_acquisition())
 

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/epics/adcore/_hdf_writer.py

@@ -1,6 +1,7 @@
 import asyncio
 from collections.abc import AsyncIterator
 from pathlib import Path
+from typing import TypeGuard
 from xml.etree import ElementTree as ET
 
 from bluesky.protocols import StreamAsset
@@ -22,6 +23,10 @@ from ._utils import (
 )
 
 
+def _is_fully_described(shape: tuple[int | None, ...]) -> TypeGuard[tuple[int, ...]]:
+    return None not in shape
+
+
 class ADHDFWriter(ADWriter[NDFileHDFIO]):
     """Allow `NDFileHDFIO` to be used within `StandardDetector`."""
 
@@ -75,6 +80,16 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         # Determine number of frames that will be saved per HDF chunk
         frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
 
+        if not _is_fully_described(detector_shape):
+            # Questions:
+            # - Can AreaDetector support this?
+            # - How to deal with chunking?
+            # Don't support for now - leave option open to support it later
+            raise ValueError(
+                "Datasets with partially unknown dimensionality "
+                "are not currently supported by ADHDFWriter."
+            )
+
         # Add the main data
         self._datasets = [
             HDFDatasetDescription(

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/epics/adcore/_utils.py

@@ -7,11 +7,12 @@ from ophyd_async.core import (
     SignalRW,
     StrictEnum,
     SubsetEnum,
+    SupersetEnum,
     wait_for_value,
 )
 
 
-class ADBaseDataType(StrictEnum):
+class ADBaseDataType(SupersetEnum):
     INT8 = "Int8"
     UINT8 = "UInt8"
     INT16 = "Int16"
@@ -22,6 +23,9 @@ class ADBaseDataType(StrictEnum):
     UINT64 = "UInt64"
     FLOAT32 = "Float32"
     FLOAT64 = "Float64"
+    # Driver database override will blank the enum string if it doesn't
+    # support a datatype
+    UNDEFINED = ""
 
 
 def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
@@ -37,7 +41,12 @@ def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
         ADBaseDataType.FLOAT32: "<f4",
         ADBaseDataType.FLOAT64: "<f8",
     }
-    return ad_dtype_to_np_dtype[ad_dtype]
+    np_type = ad_dtype_to_np_dtype.get(ad_dtype)
+    if np_type is None:
+        raise ValueError(
+            "Areadetector driver has a blank DataType, this is not supported"
+        )
+    return np_type
 
 
 def convert_pv_dtype_to_np(datatype: str) -> str:

{ophyd_async-0.10.0a3 → ophyd_async-0.10.1}/src/ophyd_async/epics/adpilatus/_pilatus.py

@@ -27,7 +27,7 @@ class PilatusDetector(AreaDetector[PilatusController]):
         config_sigs: Sequence[SignalR] = (),
     ):
         driver = PilatusDriverIO(prefix + drv_suffix)
-        controller = PilatusController(driver)
+        controller = PilatusController(driver, readout_time=readout_time)
 
         writer = writer_cls.with_io(
             prefix,