ophyd-async 0.12.1__tar.gz → 0.12.3__tar.gz

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.12.1
+Version: 0.12.3
 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
@@ -52,7 +52,7 @@ Requires-Dist: stamina>=23.1.0
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
-Requires-Dist: aioca>=1.6; extra == "ca"
+Requires-Dist: aioca>=2.0a4; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p>=4.2.0; extra == "pva"
 Provides-Extra: tango

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/pyproject.toml

@@ -29,7 +29,7 @@ requires-python = ">=3.10"
 
 [project.optional-dependencies]
 sim = ["h5py"]
-ca = ["aioca>=1.6"]
+ca = ["aioca>=2.0a4"]
 pva = ["p4p>=4.2.0"]
 tango = ["pytango==10.0.0"]
 demo = ["ipython", "matplotlib", "pyqt6"]

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.12.1'
-__version_tuple__ = version_tuple = (0, 12, 1)
+__version__ = version = '0.12.3'
+__version_tuple__ = version_tuple = (0, 12, 3)

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/epics/adcore/__init__.py

@@ -33,7 +33,6 @@ from ._utils import (
     NDAttributeParam,
     NDAttributePv,
     NDAttributePvDbrType,
-    stop_busy_record,
 )
 
 __all__ = [
@@ -64,7 +63,6 @@ __all__ = [
     "NDAttributePv",
     "NDAttributeParam",
     "NDAttributeDataType",
-    "stop_busy_record",
     "NDAttributePvDbrType",
     "NDCBFlushOnSoftTrgMode",
     "NDPluginCBIO",

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/epics/adcore/_core_logic.py

@@ -10,6 +10,7 @@ from ophyd_async.core import (
     observe_value,
     set_and_wait_for_value,
 )
+from ophyd_async.epics.core import stop_busy_record
 
 from ._core_io import (
     ADBaseIO,
@@ -18,7 +19,7 @@ from ._core_io import (
     NDCBFlushOnSoftTrgMode,
     NDPluginCBIO,
 )
-from ._utils import ADImageMode, stop_busy_record
+from ._utils import ADImageMode
 
 # Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
@@ -65,7 +66,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await stop_busy_record(self.driver.acquire, False, timeout=1)
+        await stop_busy_record(self.driver.acquire, False)
 
     async def set_exposure_time_and_acquire_period_if_supplied(
         self,
@@ -218,7 +219,7 @@ class ADBaseContAcqController(ADBaseController[ADBaseIO]):
         await self.cb_plugin.trigger.set(True, wait=False)
 
     async def disarm(self) -> None:
-        await stop_busy_record(self.cb_plugin.capture, False, timeout=1)
+        await stop_busy_record(self.cb_plugin.capture, False)
         if self._arm_status and not self._arm_status.done:
             await self._arm_status
         self._arm_status = None

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/epics/adcore/_core_writer.py

@@ -16,10 +16,10 @@ from ophyd_async.core._providers import DatasetDescriber, PathInfo, PathProvider
 from ophyd_async.core._signal import (
     observe_value,
     set_and_wait_for_value,
-    wait_for_value,
 )
 from ophyd_async.core._status import AsyncStatus
 from ophyd_async.core._utils import DEFAULT_TIMEOUT, error_if_none
+from ophyd_async.epics.core import stop_busy_record
 
 # from ophyd_async.epics.adcore._core_logic import ADBaseDatasetDescriber
 from ._core_io import (
@@ -213,8 +213,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
 
     async def close(self):
         # Already done a caput callback in _capture_status, so can't do one here
-        await self.fileio.capture.set(False, wait=False)
-        await wait_for_value(self.fileio.capture, False, DEFAULT_TIMEOUT)
+        await stop_busy_record(self.fileio.capture, False, timeout=DEFAULT_TIMEOUT)
         if self._capture_status and not self._capture_status.done:
             # We kicked off an open, so wait for it to return
             await self._capture_status

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/epics/adcore/_utils.py

@@ -1,14 +1,10 @@
 from dataclasses import dataclass
 
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    SignalDatatypeT,
     SignalR,
-    SignalRW,
     StrictEnum,
     SubsetEnum,
     SupersetEnum,
-    wait_for_value,
 )
 
 
@@ -134,13 +130,3 @@ class NDAttributeParam:
     datatype: NDAttributeDataType  # The datatype of the parameter
     addr: int = 0  # The address as seen in the INP link of the record
     description: str = ""  # A description that appears in the HDF file as an attribute
-
-
-async def stop_busy_record(
-    signal: SignalRW[SignalDatatypeT],
-    value: SignalDatatypeT,
-    timeout: float = DEFAULT_TIMEOUT,
-    status_timeout: float | None = None,
-) -> None:
-    await signal.set(value, wait=False, timeout=status_timeout)
-    await wait_for_value(signal, value, timeout=timeout)

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/epics/core/__init__.py

@@ -10,6 +10,7 @@ from ._signal import (
     epics_signal_w,
     epics_signal_x,
 )
+from ._util import stop_busy_record
 
 __all__ = [
     "PviDeviceConnector",
@@ -23,4 +24,5 @@ __all__ = [
     "epics_signal_rw_rbv",
     "epics_signal_w",
     "epics_signal_x",
+    "stop_busy_record",
 ]

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/epics/core/_util.py

@@ -4,13 +4,16 @@ from typing import Any, TypeVar, get_args, get_origin
 import numpy as np
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
     SignalBackend,
     SignalDatatypeT,
+    SignalRW,
     StrictEnum,
     SubsetEnum,
     SupersetEnum,
     get_dtype,
     get_enum_cls,
+    wait_for_value,
 )
 
 T = TypeVar("T")
@@ -76,3 +79,12 @@ class EpicsSignalBackend(SignalBackend[SignalDatatypeT]):
         self.read_pv = read_pv
         self.write_pv = write_pv
         super().__init__(datatype)
+
+
+async def stop_busy_record(
+    signal: SignalRW[SignalDatatypeT],
+    value: SignalDatatypeT,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> None:
+    await signal.set(value, wait=False)
+    await wait_for_value(signal, value, timeout=timeout)

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/epics/eiger/_odin_io.py

@@ -6,6 +6,7 @@ from event_model import DataKey  # type: ignore
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
+    AsyncStatus,
     DetectorWriter,
     Device,
     DeviceVector,
@@ -21,6 +22,7 @@ from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
+    stop_busy_record,
 )
 
 
@@ -68,10 +70,15 @@ class Odin(Device):
 
         self.file_path = epics_signal_rw_rbv(str, f"{prefix}FilePath")
         self.file_name = epics_signal_rw_rbv(str, f"{prefix}FileName")
+        self.id = epics_signal_r(str, f"{prefix}AcquisitionID_RBV")
 
         self.num_frames_chunks = epics_signal_rw(int, prefix + "NumFramesChunks")
         self.meta_active = epics_signal_r(str, prefix + "META:AcquisitionActive_RBV")
         self.meta_writing = epics_signal_r(str, prefix + "META:Writing_RBV")
+        self.meta_file_name = epics_signal_r(str, f"{prefix}META:FileName_RBV")
+        self.meta_stop = epics_signal_rw(bool, f"{prefix}META:Stop")
+
+        self.fan_ready = epics_signal_rw(float, f"{prefix}FAN:StateReady_RBV")
 
         self.data_type = epics_signal_rw_rbv(str, f"{prefix}DataType")
 
@@ -88,6 +95,7 @@ class OdinWriter(DetectorWriter):
         self._drv = odin_driver
         self._path_provider = path_provider
         self._eiger_bit_depth = Reference(eiger_bit_depth)
+        self._capture_status: AsyncStatus | None = None
         super().__init__()
 
     async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
@@ -95,17 +103,23 @@ class OdinWriter(DetectorWriter):
         self._exposures_per_event = exposures_per_event
 
         await asyncio.gather(
-            self._drv.file_path.set(str(info.directory_path)),
-            self._drv.file_name.set(info.filename),
             self._drv.data_type.set(f"UInt{await self._eiger_bit_depth().get_value()}"),
             self._drv.num_to_capture.set(0),
+            self._drv.file_path.set(str(info.directory_path)),
+            self._drv.file_name.set(info.filename),
         )
 
-        await wait_for_value(self._drv.meta_active, "Active", timeout=DEFAULT_TIMEOUT)
+        await asyncio.gather(
+            wait_for_value(
+                self._drv.meta_file_name, info.filename, timeout=DEFAULT_TIMEOUT
+            ),
+            wait_for_value(self._drv.id, info.filename, timeout=DEFAULT_TIMEOUT),
+            wait_for_value(self._drv.meta_active, "Active", timeout=DEFAULT_TIMEOUT),
+        )
 
-        await self._drv.capture.set(
-            Writing.CAPTURE, wait=False
-        )  # TODO: Investigate why we do not get a put callback when setting capture pv https://github.com/bluesky/ophyd-async/issues/866
+        self._capture_status = await set_and_wait_for_value(
+            self._drv.capture, Writing.CAPTURE, wait_for_set_completion=False
+        )
 
         await asyncio.gather(
             wait_for_value(self._drv.capture_rbv, "Capturing", timeout=DEFAULT_TIMEOUT),
@@ -146,4 +160,8 @@ class OdinWriter(DetectorWriter):
         raise NotImplementedError()
 
     async def close(self) -> None:
-        await set_and_wait_for_value(self._drv.capture, Writing.DONE)
+        await stop_busy_record(self._drv.capture, Writing.DONE, timeout=DEFAULT_TIMEOUT)
+        await self._drv.meta_stop.set(True, wait=True)
+        if self._capture_status and not self._capture_status.done:
+            await self._capture_status
+        self._capture_status = None

ophyd_async-0.12.3/src/ophyd_async/epics/pmac/__init__.py

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

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/epics/pmac/_pmac_io.py

@@ -3,6 +3,7 @@ from collections.abc import Sequence
 import numpy as np
 
 from ophyd_async.core import Array1D, Device, DeviceVector, StandardReadable
+from ophyd_async.epics import motor
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 CS_LETTERS = "ABCUVWXYZ"
@@ -13,52 +14,53 @@ class PmacTrajectoryIO(StandardReadable):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.time_array = epics_signal_rw(
-            Array1D[np.float64], prefix + ":ProfileTimeArray"
+            Array1D[np.float64], prefix + "ProfileTimeArray"
         )
-        self.user_array = epics_signal_rw(Array1D[np.int32], prefix + ":UserArray")
+        self.user_array = epics_signal_rw(Array1D[np.int32], prefix + "UserArray")
         # 1 indexed CS axes so we can index into them from the compound motor input link
         self.positions = DeviceVector(
             {
                 i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}:{letter}:Positions"
+                    Array1D[np.float64], f"{prefix}{letter}:Positions"
                 )
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
         self.use_axis = DeviceVector(
             {
-                i + 1: epics_signal_rw(bool, f"{prefix}:{letter}:UseAxis")
+                i + 1: epics_signal_rw(bool, f"{prefix}{letter}:UseAxis")
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
         self.velocities = DeviceVector(
             {
                 i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}:{letter}:Velocities"
+                    Array1D[np.float64], f"{prefix}{letter}:Velocities"
                 )
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
-        self.points_to_build = epics_signal_rw(int, prefix + ":ProfilePointsToBuild")
-        self.build_profile = epics_signal_rw(bool, prefix + ":ProfileBuild")
-        self.execute_profile = epics_signal_rw(bool, prefix + ":ProfileExecute")
-        self.scan_percent = epics_signal_r(float, prefix + ":TscanPercent_RBV")
-        self.abort_profile = epics_signal_rw(bool, prefix + ":ProfileAbort")
-        self.profile_cs_name = epics_signal_rw(str, prefix + ":ProfileCsName")
-        self.calculate_velocities = epics_signal_rw(bool, prefix + ":ProfileCalcVel")
+        self.points_to_build = epics_signal_rw(int, prefix + "ProfilePointsToBuild")
+        self.build_profile = epics_signal_rw(bool, prefix + "ProfileBuild")
+        self.execute_profile = epics_signal_rw(bool, prefix + "ProfileExecute")
+        self.scan_percent = epics_signal_r(float, prefix + "TscanPercent_RBV")
+        self.abort_profile = epics_signal_rw(bool, prefix + "ProfileAbort")
+        self.profile_cs_name = epics_signal_rw(str, prefix + "ProfileCsName")
+        self.calculate_velocities = epics_signal_rw(bool, prefix + "ProfileCalcVel")
 
         super().__init__(name=name)
 
 
-class PmacAxisIO(Device):
+class PmacAxisAssignmentIO(Device):
     """A Device that (direct) moves a PMAC Coordinate System Motor.
 
     Note that this does not go through a motor record.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.cs_axis_letter = epics_signal_r(str, f"{prefix}:CsAxis_RBV")
-        self.cs_port = epics_signal_r(str, f"{prefix}:CsPort_RBV")
+        self.cs_axis_letter = epics_signal_r(str, f"{prefix}CsAxis_RBV")
+        self.cs_port = epics_signal_r(str, f"{prefix}CsPort_RBV")
+        self.cs_number = epics_signal_r(int, f"{prefix}CsRaw_RBV")
         super().__init__(name=name)
 
 
@@ -66,12 +68,10 @@ class PmacCoordIO(Device):
     """A Device that represents a Pmac Coordinate System."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.defer_moves = epics_signal_r(bool, f"{prefix}:DeferMoves")
+        self.defer_moves = epics_signal_rw(bool, f"{prefix}DeferMoves")
         self.cs_axis_setpoint = DeviceVector(
             {
-                i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}:M{i + 1}:DirectDemand"
-                )
+                i + 1: epics_signal_rw(np.float64, f"{prefix}M{i + 1}:DirectDemand")
                 for i in range(len(CS_LETTERS))
             }
         )
@@ -84,15 +84,25 @@ class PmacIO(Device):
     def __init__(
         self,
         prefix: str,
-        axis_nums: Sequence[int],
+        raw_motors: Sequence[motor.Motor],
         coord_nums: Sequence[int],
         name: str = "",
     ) -> None:
-        self.axis = DeviceVector(
-            {axis: PmacAxisIO(f"{prefix}:M{axis}") for axis in axis_nums}
+        motor_prefixes = [motor.motor_egu.source.split(".")[0] for motor in raw_motors]
+
+        self.assignment = DeviceVector(
+            {
+                i: PmacAxisAssignmentIO(motor_prefix)
+                for i, motor_prefix in enumerate(motor_prefixes)
+            }
         )
+
+        # Public Look up for motor to axis assignment DeviceVector index
+
+        self.motor_assignment_index = {motor: i for i, motor in enumerate(raw_motors)}
+
         self.coord = DeviceVector(
-            {coord: PmacCoordIO(f"{prefix}:CS{coord}") for coord in coord_nums}
+            {coord: PmacCoordIO(prefix=f"{prefix}CS{coord}:") for coord in coord_nums}
         )
         # Trajectory PVs have the same prefix as the pmac device
         self.trajectory = PmacTrajectoryIO(prefix)

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/fastcs/eiger/_eiger.py

@@ -33,7 +33,7 @@ class EigerDetector(StandardDetector):
             OdinWriter(
                 path_provider,
                 self.odin,
-                self.drv.detector.bit_depth_readout,
+                self.drv.detector.bit_depth_image,
             ),
             name=name,
         )

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async/fastcs/eiger/_eiger_io.py

@@ -23,11 +23,12 @@ class EigerStreamIO(Device):
 
 
 class EigerDetectorIO(Device):
-    bit_depth_readout: SignalR[int]
+    bit_depth_image: SignalR[int]
     state: SignalR[str]
     count_time: SignalRW[float]
     frame_time: SignalRW[float]
     nimages: SignalRW[int]
+    ntrigger: SignalRW[int]
     nexpi: SignalRW[int]
     trigger_mode: SignalRW[str]
     roi_mode: SignalRW[str]

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.12.1
+Version: 0.12.3
 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
@@ -52,7 +52,7 @@ Requires-Dist: stamina>=23.1.0
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
-Requires-Dist: aioca>=1.6; extra == "ca"
+Requires-Dist: aioca>=2.0a4; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p>=4.2.0; extra == "pva"
 Provides-Extra: tango

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/src/ophyd_async.egg-info/requires.txt

@@ -8,7 +8,7 @@ pydantic-numpy
 stamina>=23.1.0
 
 [ca]
-aioca>=1.6
+aioca>=2.0a4
 
 [demo]
 ipython

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/tests/epics/eiger/test_odin_io.py

@@ -1,11 +1,17 @@
+import asyncio
+from asyncio import Event
 from pathlib import Path
-from unittest.mock import ANY, AsyncMock, MagicMock, call, patch
+from unittest.mock import ANY, AsyncMock, MagicMock
 
 import pytest
 
-from ophyd_async.core import DEFAULT_TIMEOUT, init_devices
+from ophyd_async.core import init_devices
 from ophyd_async.epics.eiger import Odin, OdinWriter, Writing
-from ophyd_async.testing import get_mock_put, set_mock_value
+from ophyd_async.testing import (
+    callback_on_mock_put,
+    get_mock_put,
+    set_mock_value,
+)
 
 ODIN_DETECTOR_NAME = "odin_detector"
 EIGER_BIT_DEPTH = 16
@@ -19,22 +25,26 @@ def odin_driver_and_writer(RE) -> OdinDriverAndWriter:
     with init_devices(mock=True):
         driver = Odin("")
         writer = OdinWriter(MagicMock(), driver, eiger_bit_depth)
+    writer._path_provider.return_value.filename = "filename.h5"  # type: ignore
+    return driver, writer
+
 
-    # Set meta and capturing pvs high
+def initialise_signals_to_armed(driver):
     set_mock_value(driver.meta_active, "Active")
     set_mock_value(driver.capture_rbv, "Capturing")
     set_mock_value(driver.meta_writing, "Writing")
-    return driver, writer
+    set_mock_value(driver.meta_file_name, "filename.h5")
+    set_mock_value(driver.id, "filename.h5")
 
 
 async def test_when_open_called_then_file_correctly_set(
     odin_driver_and_writer: OdinDriverAndWriter, tmp_path: Path
 ):
     driver, writer = odin_driver_and_writer
+    initialise_signals_to_armed(driver)
     path_info = writer._path_provider.return_value  # type: ignore
-    expected_filename = "filename.h5"
     path_info.directory_path = tmp_path
-    path_info.filename = expected_filename
+    expected_filename = "filename.h5"
 
     await writer.open(ODIN_DETECTOR_NAME)
 
@@ -46,6 +56,7 @@ async def test_when_open_called_then_all_expected_signals_set(
     odin_driver_and_writer: OdinDriverAndWriter,
 ):
     driver, writer = odin_driver_and_writer
+    initialise_signals_to_armed(driver)
 
     await writer.open(ODIN_DETECTOR_NAME)
 
@@ -59,6 +70,7 @@ async def test_bit_depth_is_passed_before_open_and_set_to_data_type_after_open(
     odin_driver_and_writer: OdinDriverAndWriter,
 ):
     driver, writer = odin_driver_and_writer
+    initialise_signals_to_armed(driver)
 
     assert await writer._eiger_bit_depth().get_value() == EIGER_BIT_DEPTH
     assert await driver.data_type.get_value() == ""
@@ -72,6 +84,8 @@ async def test_given_data_shape_set_when_open_called_then_describe_has_correct_s
     odin_driver_and_writer: OdinDriverAndWriter,
 ):
     driver, writer = odin_driver_and_writer
+    initialise_signals_to_armed(driver)
+
     set_mock_value(driver.image_width, 1024)
     set_mock_value(driver.image_height, 768)
     description = await writer.open(ODIN_DETECTOR_NAME)
@@ -87,29 +101,39 @@ async def test_when_closed_then_data_capture_turned_off(
 
 
 @pytest.mark.asyncio
-@patch("ophyd_async.epics.eiger._odin_io.wait_for_value")
-async def test_wait_for_active_before_capture_then_wait_for_writing(
-    mock_wait_for_value,
+async def test_wait_for_active_and_file_names_before_capture_then_wait_for_writing(
     odin_driver_and_writer,
 ):
     driver, writer = odin_driver_and_writer
-    writer._drv.capture.set = AsyncMock()
-
-    mock_manager = AsyncMock()
-    mock_manager.attach_mock(mock_wait_for_value, "mock_wait_for_value")
-    mock_manager.attach_mock(writer._drv.capture.set, "mock_capture_set")
 
-    await writer.open(ODIN_DETECTOR_NAME)
-
-    expected_calls = [
-        call.mock_wait_for_value(driver.meta_active, "Active", timeout=DEFAULT_TIMEOUT),
-        call.mock_capture_set(Writing.CAPTURE, wait=False),
-        call.mock_wait_for_value(
-            driver.capture_rbv, "Capturing", timeout=DEFAULT_TIMEOUT
-        ),
-        call.mock_wait_for_value(
-            driver.meta_writing, "Writing", timeout=DEFAULT_TIMEOUT
-        ),
-    ]
-
-    assert mock_manager.mock_calls == expected_calls
+    file_name_is_set = Event()
+    capture_is_set = Event()
+    callback_on_mock_put(
+        driver.file_name, lambda *args, **kwargs: file_name_is_set.set()
+    )
+    callback_on_mock_put(driver.capture, lambda *args, **kwargs: capture_is_set.set())
+
+    async def set_waited_signals():
+        set_mock_value(driver.meta_active, "Active")
+        set_mock_value(driver.id, "filename.h5")
+        set_mock_value(driver.meta_file_name, "filename.h5")
+
+    async def set_ready_signals():
+        set_mock_value(driver.meta_writing, "Writing")
+        set_mock_value(driver.capture_rbv, "Capturing")
+
+    async def wait_and_set_signals():
+        # Block until filename is set
+        await file_name_is_set.wait()
+        # Allow writer.open to proceed to wait_for_value.
+        await asyncio.sleep(0.1)
+        # writer.open now waits on signals; set these, and unset event
+        await set_waited_signals()
+        # Block until capture sets event
+        await capture_is_set.wait()
+        # Allow writer.open to proceed to wait_for_value.
+        await asyncio.sleep(0.1)
+        # writer.open now waits on signals; set these
+        await set_ready_signals()
+
+    await asyncio.gather(writer.open(ODIN_DETECTOR_NAME), wait_and_set_signals())

{ophyd_async-0.12.1 → ophyd_async-0.12.3}/tests/epics/pmac/test_pmac_io.py

@@ -1,5 +1,6 @@
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.pmac import (
-    PmacAxisIO,
+    PmacAxisAssignmentIO,
     PmacCoordIO,
     PmacIO,
     PmacTrajectoryIO,  # type: ignore
@@ -8,16 +9,29 @@ from ophyd_async.epics.pmac import (
 
 def test_pmac_io():
     """Instantiate a PmacIO object that looks like the P47 training beamline"""
+    raw_motors = [
+        Motor("BL47P-MO-MAP-01:STAGE:X:"),
+        Motor("BL47P-MO-MAP-01:STAGE:A:"),
+    ]
 
     pmac = PmacIO(
-        axis_nums=[1, 2],
+        prefix="BL47P-MO-BRICK-01:",
+        raw_motors=raw_motors,
         coord_nums=[1, 9],
-        prefix="BL47P-MO-BRICK-01",
         name="p47-brick-01",
     )
 
     assert pmac.name == "p47-brick-01"
 
+    # check assignments
+    assert len(pmac.assignment) == 2
+    assert isinstance(pmac.assignment[0], PmacAxisAssignmentIO)
+    assert isinstance(pmac.assignment[1], PmacAxisAssignmentIO)
+
+    # check_look_up
+    assert pmac.motor_assignment_index[raw_motors[0]] == 0
+    assert pmac.motor_assignment_index[raw_motors[1]] == 1
+
     # check coords PVs
     assert pmac.coord[1].defer_moves.source == "ca://BL47P-MO-BRICK-01:CS1:DeferMoves"
     assert (
@@ -34,8 +48,13 @@ def test_pmac_io():
     )
 
     # check axes PVs
-    assert pmac.axis[1].cs_axis_letter.source == "ca://BL47P-MO-BRICK-01:M1:CsAxis_RBV"
-    assert pmac.axis[1].cs_port.source == "ca://BL47P-MO-BRICK-01:M1:CsPort_RBV"
+    assert (
+        pmac.assignment[1].cs_axis_letter.source
+        == "ca://BL47P-MO-MAP-01:STAGE:A:CsAxis_RBV"
+    )
+    assert (
+        pmac.assignment[1].cs_port.source == "ca://BL47P-MO-MAP-01:STAGE:A:CsPort_RBV"
+    )
 
     # check trajectory scan PVs
     assert (
@@ -53,7 +72,7 @@ def test_pmac_trajectory_io():
     """Instantiate a PmacTrajectoryIO object with a specific prefix."""
 
     pmac_trajectory = PmacTrajectoryIO(
-        prefix="BL47P-MO-BRICK-01", name="p47-brick-01-trajectory"
+        prefix="BL47P-MO-BRICK-01:", name="p47-brick-01-trajectory"
     )
 
     assert pmac_trajectory.name == "p47-brick-01-trajectory"
@@ -69,9 +88,11 @@ def test_pmac_trajectory_io():
 
 
 def test_pmac_axis_io():
-    """Instantiate a PmacAxisIO object with a specific prefix."""
+    """Instantiate a PmacAxisAssignmentIO object with a specific prefix."""
 
-    pmac_axis = PmacAxisIO(prefix="BL47P-MO-BRICK-01:M1", name="p47-brick-01-axis")
+    pmac_axis = PmacAxisAssignmentIO(
+        prefix="BL47P-MO-BRICK-01:M1:", name="p47-brick-01-axis"
+    )
 
     assert pmac_axis.name == "p47-brick-01-axis"
     assert pmac_axis.cs_axis_letter.source == "ca://BL47P-MO-BRICK-01:M1:CsAxis_RBV"
@@ -81,7 +102,7 @@ def test_pmac_axis_io():
 def test_pmac_coord_io():
     """Instantiate a PmacCoordIO object with a specific prefix."""
 
-    pmac_coord = PmacCoordIO(prefix="BL47P-MO-BRICK-01:CS1", name="p47-brick-01-coord")
+    pmac_coord = PmacCoordIO(prefix="BL47P-MO-BRICK-01:CS1:", name="p47-brick-01-coord")
 
     assert pmac_coord.name == "p47-brick-01-coord"
     assert pmac_coord.defer_moves.source == "ca://BL47P-MO-BRICK-01:CS1:DeferMoves"