ophyd-async 0.10.1__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()
@@ -188,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
 
@@ -692,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
@@ -704,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.
 
@@ -724,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/_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/_hdf_writer.py

@@ -54,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))
 
@@ -100,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()
@@ -149,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")

ophyd_async/epics/motor.py

@@ -14,7 +14,6 @@ from bluesky.protocols import (
     Stoppable,
     Subscribable,
 )
-from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
     CALCULATE_TIMEOUT,
@@ -22,16 +21,18 @@ from ophyd_async.core import (
     AsyncStatus,
     CalculatableTimeout,
     Callback,
+    FlyMotorInfo,
     StandardReadable,
     StrictEnum,
     WatchableAsyncStatus,
     WatcherUpdate,
+    error_if_none,
     observe_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
-__all__ = ["MotorLimitsException", "FlyMotorInfo", "Motor"]
+__all__ = ["MotorLimitsException", "Motor"]
 
 
 class MotorLimitsException(Exception):
@@ -40,26 +41,6 @@ class MotorLimitsException(Exception):
     pass
 
 
-class FlyMotorInfo(BaseModel):
-    """Minimal set of information required to fly a motor."""
-
-    start_position: float = Field(frozen=True)
-    """Absolute position of the motor once it finishes accelerating to desired
-    velocity, in motor EGUs"""
-
-    end_position: float = Field(frozen=True)
-    """Absolute position of the motor once it begins decelerating from desired
-    velocity, in EGUs"""
-
-    time_for_move: float = Field(frozen=True, gt=0)
-    """Time taken for the motor to get from start_position to end_position, excluding
-    run-up and run-down, in seconds."""
-
-    timeout: CalculatableTimeout = Field(frozen=True, default=CALCULATE_TIMEOUT)
-    """Maximum time for the complete motor move, including run up and run down.
-    Defaults to `time_for_move` + run up and run down times + 10s."""
-
-
 class OffsetMode(StrictEnum):
     VARIABLE = "Variable"
     FROZEN = "Frozen"
@@ -111,15 +92,12 @@ class Motor(
         # Whether set() should complete successfully or not
         self._set_success = True
 
-        # end_position of a fly move, with run_up_distance added on.
-        self._fly_completed_position: float | None = None
+        # Currently requested fly info, stored in prepare
+        self._fly_info: FlyMotorInfo | None = None
 
         # Set on kickoff(), complete when motor reaches self._fly_completed_position
         self._fly_status: WatchableAsyncStatus | None = None
 
-        # Set during prepare
-        self._fly_timeout: CalculatableTimeout | None = CALCULATE_TIMEOUT
-
         super().__init__(name=name)
 
     def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
@@ -131,41 +109,64 @@ class Motor(
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
         """Move to the beginning of a suitable run-up distance ready for a flyscan."""
-        self._fly_timeout = value.timeout
+        self._fly_info = value
 
         # Velocity, at which motor travels from start_position to end_position, in motor
         # egu/s.
-        fly_velocity = await self._prepare_velocity(
-            value.start_position,
-            value.end_position,
-            value.time_for_move,
+        max_speed, egu = await asyncio.gather(
+            self.max_velocity.get_value(), self.motor_egu.get_value()
         )
+        if abs(value.velocity) > max_speed:
+            raise MotorLimitsException(
+                f"Velocity {abs(value.velocity)} {egu}/s was requested for a motor "
+                f" with max speed of {max_speed} {egu}/s"
+            )
+
+        acceleration_time = await self.acceleration_time.get_value()
+        ramp_up_start_pos = value.ramp_up_start_pos(acceleration_time)
+        ramp_down_end_pos = value.ramp_down_end_pos(acceleration_time)
 
-        # start_position with run_up_distance added on.
-        fly_prepared_position = await self._prepare_motor_path(
-            abs(fly_velocity), value.start_position, value.end_position
+        motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
+            self.low_limit_travel.get_value(),
+            self.high_limit_travel.get_value(),
+            self.motor_egu.get_value(),
         )
 
-        await self.set(fly_prepared_position)
-        await self.velocity.set(abs(fly_velocity))
+        if (
+            not motor_upper_limit >= ramp_up_start_pos >= motor_lower_limit
+            or not motor_upper_limit >= ramp_down_end_pos >= motor_lower_limit
+        ):
+            raise MotorLimitsException(
+                f"Motor trajectory for requested fly is from "
+                f"{ramp_up_start_pos}{egu} to "
+                f"{ramp_down_end_pos}{egu} but motor limits are "
+                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+            )
+
+        # move to prepare position at maximum velocity
+        await self.velocity.set(abs(max_speed))
+        await self.set(ramp_up_start_pos)
+
+        # Set velocity we will be using for the flyscan
+        await self.velocity.set(abs(value.velocity))
 
     @AsyncStatus.wrap
     async def kickoff(self):
         """Begin moving motor from prepared position to final position."""
-        if not self._fly_completed_position:
-            msg = "Motor must be prepared before attempting to kickoff"
-            raise RuntimeError(msg)
+        fly_info = error_if_none(
+            self._fly_info, "Motor must be prepared before attempting to kickoff"
+        )
 
+        acceleration_time = await self.acceleration_time.get_value()
         self._fly_status = self.set(
-            self._fly_completed_position, timeout=self._fly_timeout
+            fly_info.ramp_down_end_pos(acceleration_time),
+            timeout=fly_info.timeout,
         )
 
     def complete(self) -> WatchableAsyncStatus:
         """Mark as complete once motor reaches completed position."""
-        if not self._fly_status:
-            msg = "kickoff not called"
-            raise RuntimeError(msg)
-        return self._fly_status
+        fly_status = error_if_none(self._fly_status, "kickoff not called")
+        return fly_status
 
     @WatchableAsyncStatus.wrap
     async def set(  # type: ignore
@@ -220,22 +221,6 @@ class Motor(
         # the move above, so need to pass wait=False
         await self.motor_stop.set(1, wait=False)
 
-    async def _prepare_velocity(
-        self, start_position: float, end_position: float, time_for_move: float
-    ) -> float:
-        fly_velocity = (end_position - start_position) / time_for_move
-        max_speed, egu = await asyncio.gather(
-            self.max_velocity.get_value(), self.motor_egu.get_value()
-        )
-        if abs(fly_velocity) > max_speed:
-            raise MotorLimitsException(
-                f"Motor speed of {abs(fly_velocity)} {egu}/s was requested for a motor "
-                f" with max speed of {max_speed} {egu}/s"
-            )
-        # move to prepare position at maximum velocity
-        await self.velocity.set(abs(max_speed))
-        return fly_velocity
-
     async def locate(self) -> Location[float]:
         """Return the current setpoint and readback of the motor."""
         setpoint, readback = await asyncio.gather(
@@ -250,38 +235,3 @@ class Motor(
     def clear_sub(self, function: Callback[dict[str, Reading[float]]]) -> None:
         """Unsubscribe."""
         self.user_readback.clear_sub(function)
-
-    async def _prepare_motor_path(
-        self, fly_velocity: float, start_position: float, end_position: float
-    ) -> float:
-        # Distance required for motor to accelerate from stationary to fly_velocity, and
-        # distance required for motor to decelerate from fly_velocity to stationary
-        run_up_distance = (
-            (await self.acceleration_time.get_value()) * fly_velocity * 0.5
-        )
-
-        direction = 1 if end_position > start_position else -1
-        self._fly_completed_position = end_position + (run_up_distance * direction)
-
-        # Prepared position not used after prepare, so no need to store in self
-        fly_prepared_position = start_position - (run_up_distance * direction)
-
-        motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
-            self.low_limit_travel.get_value(),
-            self.high_limit_travel.get_value(),
-            self.motor_egu.get_value(),
-        )
-
-        if (
-            not motor_upper_limit >= fly_prepared_position >= motor_lower_limit
-            or not motor_upper_limit
-            >= self._fly_completed_position
-            >= motor_lower_limit
-        ):
-            raise MotorLimitsException(
-                f"Motor trajectory for requested fly is from "
-                f"{fly_prepared_position}{egu} to "
-                f"{self._fly_completed_position}{egu} but motor limits are "
-                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
-            )
-        return fly_prepared_position

ophyd_async/epics/pmac/__init__.py

@@ -0,0 +1,3 @@
+from ._pmac_io import PmacAxisIO, PmacCoordIO, PmacIO, PmacTrajectoryIO
+
+__all__ = ["PmacAxisIO", "PmacCoordIO", "PmacIO", "PmacTrajectoryIO"]