ophyd-async 0.10.0a4__py3-none-any.whl → 0.11__py3-none-any.whl

ophyd_async/core/_signal.py

@@ -31,6 +31,7 @@ from ._utils import (
     Callback,
     LazyMock,
     T,
+    error_if_none,
 )
 
 
@@ -125,10 +126,8 @@ class _SignalCache(Generic[SignalDatatypeT]):
         self._signal.log.debug(f"Closing subscription on source {self._signal.source}")
 
     def _ensure_reading(self) -> Reading[SignalDatatypeT]:
-        if not self._reading:
-            msg = "Monitor not working"
-            raise RuntimeError(msg)
-        return self._reading
+        reading = error_if_none(self._reading, "Monitor not working")
+        return reading
 
     async def get_reading(self) -> Reading[SignalDatatypeT]:
         await self._valid.wait()
@@ -163,7 +162,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:
@@ -183,11 +187,8 @@ class SignalR(Signal[SignalDatatypeT], AsyncReadable, AsyncStageable, Subscribab
         if cached is None:
             cached = self._cache is not None
         if cached:
-            if not self._cache:
-                msg = f"{self.source} not being monitored"
-                raise RuntimeError(msg)
-            # assert self._cache, f"{self.source} not being monitored"
-            return self._cache
+            cache = error_if_none(self._cache, f"{self.source} not being monitored")
+            return cache
         else:
             return self._connector.backend
 
@@ -687,7 +688,7 @@ async def set_and_wait_for_value(
     )
 
 
-def walk_rw_signals(device: Device, path_prefix: str = "") -> dict[str, SignalRW[Any]]:
+def walk_rw_signals(device: Device) -> dict[str, SignalRW[Any]]:
     """Retrieve all SignalRWs from a device.
 
     Stores retrieved signals with their dotted attribute paths in a dictionary. Used as
@@ -699,19 +700,12 @@ def walk_rw_signals(device: Device, path_prefix: str = "") -> dict[str, SignalRW
         A dictionary matching the string attribute path of a SignalRW with the
         signal itself.
     """
-    signals: dict[str, SignalRW[Any]] = {}
-
-    for attr_name, attr in device.children():
-        dot_path = f"{path_prefix}{attr_name}"
-        if type(attr) is SignalRW:
-            signals[dot_path] = attr
-        attr_signals = walk_rw_signals(attr, path_prefix=dot_path + ".")
-        signals.update(attr_signals)
-    return signals
+    all_devices = walk_devices(device)
+    return {path: dev for path, dev in all_devices.items() if type(dev) is SignalRW}
 
 
 async def walk_config_signals(
-    device: Device, path_prefix: str = ""
+    device: Device,
 ) -> dict[str, SignalRW[Any]]:
     """Retrieve all configuration signals from a device.
 
@@ -719,28 +713,54 @@ async def walk_config_signals(
     part of saving and loading a device.
 
     :param device: Device to retrieve configuration signals from.
-    :param path_prefix: For internal use, leave blank when calling the method.
     :return:
         A dictionary matching the string attribute path of a SignalRW with the
         signal itself.
     """
-    signals: dict[str, SignalRW[Any]] = {}
     config_names: list[str] = []
     if isinstance(device, Configurable):
         configuration = device.read_configuration()
         if inspect.isawaitable(configuration):
             configuration = await configuration
         config_names = list(configuration.keys())
-    for attr_name, attr in device.children():
-        dot_path = f"{path_prefix}{attr_name}"
-        if isinstance(attr, SignalRW) and attr.name in config_names:
-            signals[dot_path] = attr
-        signals.update(await walk_config_signals(attr, path_prefix=dot_path + "."))
 
-    return signals
+    all_devices = walk_devices(device)
+    return {
+        path: dev
+        for path, dev in all_devices.items()
+        if isinstance(dev, SignalRW) and dev.name in config_names
+    }
 
 
 class Ignore:
     """Annotation to ignore a signal when connecting a device."""
 
     pass
+
+
+def walk_devices(device: Device, path_prefix: str = "") -> dict[str, Device]:
+    """Recursively retrieve all Devices from a device tree.
+
+    :param device: Root device to start from.
+    :param path_prefix: For internal use, leave blank when calling the method.
+    :return: A dictionary mapping dotted attribute paths to Device instances.
+    """
+    devices: dict[str, Device] = {}
+    for attr_name, attr in device.children():
+        dot_path = f"{path_prefix}{attr_name}"
+        devices[dot_path] = attr
+        devices.update(walk_devices(attr, path_prefix=dot_path + "."))
+    return devices
+
+
+def walk_signal_sources(device: Device) -> dict[str, str]:
+    """Recursively gather the `source` field from every Signal in a device tree.
+
+    :param device: Root device to start from.
+    :param path_prefix: For internal use, leave blank when calling the method.
+    :return: A dictionary mapping dotted attribute paths to Signal source strings.
+    """
+    all_devices = walk_devices(device)
+    return {
+        path: dev.source for path, dev in all_devices.items() if isinstance(dev, Signal)
+    }

ophyd_async/core/_signal_backend.py

@@ -176,7 +176,7 @@ def _datakey_dtype_numpy(
         raise TypeError(f"Can't make dtype_numpy for {datatype}")
 
 
-def _datakey_shape(value: SignalDatatype) -> list[int]:
+def _datakey_shape(value: SignalDatatype) -> list[int | None]:
     if type(value) in _primitive_dtype or isinstance(value, EnumTypes):
         return []
     elif isinstance(value, np.ndarray):

ophyd_async/core/_table.py

@@ -4,10 +4,10 @@ from collections.abc import Callable, Sequence
 from typing import Annotated, Any, TypeVar, get_origin, get_type_hints
 
 import numpy as np
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import ConfigDict, Field, model_validator
 from pydantic_numpy.helper.annotation import NpArrayPydanticAnnotation
 
-from ._utils import get_dtype
+from ._utils import ConfinedModel, get_dtype
 
 TableSubclass = TypeVar("TableSubclass", bound="Table")
 
@@ -26,7 +26,7 @@ def _make_default_factory(dtype: np.dtype) -> Callable[[], np.ndarray]:
     return numpy_array_default_factory
 
 
-class Table(BaseModel):
+class Table(ConfinedModel):
     """An abstraction of a Table where each field is a column.
 
     For example:

ophyd_async/core/_utils.py

@@ -17,6 +17,7 @@ from typing import (
 from unittest.mock import Mock
 
 import numpy as np
+from pydantic import BaseModel, ConfigDict
 
 T = TypeVar("T")
 V = TypeVar("V")
@@ -377,3 +378,27 @@ class LazyMock:
             if self.parent is not None:
                 self.parent().attach_mock(self._mock, self.name)
         return self._mock
+
+
+class ConfinedModel(BaseModel):
+    """A base class confined to explicitly defined fields in the model schema."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+
+def error_if_none(value: T | None, msg: str) -> T:
+    """Check and return the value if not None.
+
+    :param value: The value to check
+    :param msg: The `RuntimeError` message to raise if it is None
+    :raises RuntimeError: If the value is None
+    :returns: The value if not None
+
+    Used to implement a pattern where a variable is None at init, then
+    changed by a method, then used in a later method.
+    """
+    if value is None:
+        raise RuntimeError(msg)
+    return value

ophyd_async/core/_yaml_settings.py

@@ -6,9 +6,9 @@ from typing import Any
 import numpy as np
 import numpy.typing as npt
 import yaml
-from pydantic import BaseModel
 
 from ._settings import SettingsProvider
+from ._utils import ConfinedModel
 
 
 def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.Node:
@@ -18,7 +18,7 @@ def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.No
 
 
 def pydantic_model_abstraction_representer(
-    dumper: yaml.Dumper, model: BaseModel
+    dumper: yaml.Dumper, model: ConfinedModel
 ) -> yaml.Node:
     return dumper.represent_data(model.model_dump(mode="python"))
 
@@ -39,7 +39,7 @@ class YamlSettingsProvider(SettingsProvider):
     async def store(self, name: str, data: dict[str, Any]):
         yaml.add_representer(np.ndarray, ndarray_representer, Dumper=yaml.Dumper)
         yaml.add_multi_representer(
-            BaseModel,
+            ConfinedModel,
             pydantic_model_abstraction_representer,
             Dumper=yaml.Dumper,
         )

ophyd_async/epics/adandor/__init__.py

@@ -1,9 +1,15 @@
+"""Support for the ADAndor areaDetector driver.
+
+https://github.com/areaDetector/ADAndor.
+"""
+
 from ._andor import Andor2Detector
 from ._andor_controller import Andor2Controller
-from ._andor_io import Andor2DriverIO
+from ._andor_io import Andor2DriverIO, Andor2TriggerMode
 
 __all__ = [
     "Andor2Detector",
     "Andor2Controller",
     "Andor2DriverIO",
+    "Andor2TriggerMode",
 ]

ophyd_async/epics/adandor/_andor_controller.py

@@ -12,15 +12,11 @@ _MIN_DEAD_TIME = 0.1
 _MAX_NUM_IMAGE = 999_999
 
 
+# The deadtime of an Andor2 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
 class Andor2Controller(adcore.ADBaseController[Andor2DriverIO]):
-    """For controlling the Andor 2 detector."""
-
-    def __init__(
-        self,
-        driver: Andor2DriverIO,
-        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
-    ) -> None:
-        super().__init__(driver, good_states=good_states)
+    """DetectorCobntroller for Andor2DriverIO."""
 
     def get_deadtime(self, exposure: float | None) -> float:
         return _MIN_DEAD_TIME + (exposure or 0)
@@ -29,6 +25,7 @@ class Andor2Controller(adcore.ADBaseController[Andor2DriverIO]):
         await self.set_exposure_time_and_acquire_period_if_supplied(
             trigger_info.livetime
         )
+
         await asyncio.gather(
             self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
             self.driver.num_images.set(

ophyd_async/epics/adandor/_andor_io.py

@@ -1,8 +1,9 @@
-from ophyd_async.core import StrictEnum, SubsetEnum
-from ophyd_async.epics.adcore import ADBaseIO
+from typing import Annotated as A
+
+from ophyd_async.core import SignalR, SignalRW, StrictEnum
+from ophyd_async.epics import adcore
 from ophyd_async.epics.core import (
-    epics_signal_r,
-    epics_signal_rw,
+    PvSuffix,
 )
 
 
@@ -15,20 +16,12 @@ class Andor2TriggerMode(StrictEnum):
     SOFTWARE = "Software"
 
 
-class Andor2DataType(SubsetEnum):
-    UINT16 = "UInt16"
-    UINT32 = "UInt32"
-    FLOAT32 = "Float32"
-    FLOAT64 = "Float64"
-
+class Andor2DriverIO(adcore.ADBaseIO):
+    """Driver for andor model:DU897_BV as deployed on p99.
 
-class Andor2DriverIO(ADBaseIO):
-    """Epics pv for andor model:DU897_BV as deployed on p99."""
+    This mirrors the interface provided by AdAndor/db/andor.template.
+    https://areadetector.github.io/areaDetector/ADAndor/andorDoc.html
+    """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        super().__init__(prefix, name=name)
-        self.trigger_mode = epics_signal_rw(Andor2TriggerMode, prefix + "TriggerMode")
-        self.data_type = epics_signal_r(Andor2DataType, prefix + "DataType_RBV")  # type: ignore
-        self.andor_accumulate_period = epics_signal_r(
-            float, prefix + "AndorAccumulatePeriod_RBV"
-        )
+    trigger_mode: A[SignalRW[Andor2TriggerMode], PvSuffix.rbv("TriggerMode")]
+    andor_accumulate_period: A[SignalR[float], PvSuffix("AndorAccumulatePeriod_RBV")]

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/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`."""
 
@@ -49,10 +54,7 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
     async def open(
         self, name: str, exposures_per_event: PositiveInt = 1
     ) -> dict[str, DataKey]:
-        self._composer = None
-
         # Setting HDF writer specific signals
-
         # Make sure we are using chunk auto-sizing
         await asyncio.gather(self.fileio.chunk_size_auto.set(True))
 
@@ -75,6 +77,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(
@@ -85,6 +97,13 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
                 chunk_shape=(frames_per_chunk, *detector_shape),
             )
         ]
+
+        self._composer = HDFDocumentComposer(
+            # See https://github.com/bluesky/ophyd-async/issues/122
+            Path(await self.fileio.full_file_name.get_value()),
+            self._datasets,
+        )
+
         # And all the scalar datasets
         for plugin in self._plugins.values():
             maybe_xml = await plugin.nd_attributes_file.get_value()
@@ -134,20 +153,9 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
+        if self._composer is None:
+            msg = f"open() not called on {self}"
+            raise RuntimeError(msg)
         await self.fileio.flush_now.set(True)
-        if indices_written:
-            if not self._composer:
-                path = Path(await self.fileio.full_file_name.get_value())
-                self._composer = HDFDocumentComposer(
-                    # See https://github.com/bluesky/ophyd-async/issues/122
-                    path,
-                    self._datasets,
-                )
-                # stream resource says "here is a dataset",
-                # stream datum says "here are N frames in that stream resource",
-                # you get one stream resource and many stream datums per scan
-
-                for doc in self._composer.stream_resources():
-                    yield "stream_resource", doc
-            for doc in self._composer.stream_data(indices_written):
-                yield "stream_datum", doc
+        for doc in self._composer.make_stream_docs(indices_written):
+            yield doc

ophyd_async/epics/eiger/_odin_io.py

@@ -45,9 +45,11 @@ class OdinNode(Device):
 
 
 class Odin(Device):
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(self, prefix: str, name: str = "", nodes: int = 4) -> None:
+        # default nodes is set to 4, MX 16M Eiger detectors - nodes = 4.
+        # B21 4M Eiger detector - nodes = 1
         self.nodes = DeviceVector(
-            {i: OdinNode(f"{prefix[:-1]}{i + 1}:") for i in range(4)}
+            {i: OdinNode(f"{prefix[:-1]}{i + 1}:") for i in range(nodes)}
         )
 
         self.capture = epics_signal_rw(Writing, f"{prefix}Capture")