ophyd-async 0.12.1__py3-none-any.whl → 0.12.3__py3-none-any.whl

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/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/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/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/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/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/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/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/epics/pmac/__init__.py

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

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/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/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.dist-info → ophyd_async-0.12.3.dist-info}/METADATA

@@ -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.dist-info → ophyd_async-0.12.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 ophyd_async/__init__.py,sha256=dcAA3qsj1nNIMe5l-v2tlduZ_ypwBmyuHe45Lsq4k4w,206
 ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
 ophyd_async/_docs_parser.py,sha256=gPYrigfSbYCF7QoSf2UvE-cpQu4snSssl7ZWN-kKDzI,352
-ophyd_async/_version.py,sha256=DzB47l1iPNTY8yuA60VuZvneNqNdRBd1svEjKxC37o4,513
+ophyd_async/_version.py,sha256=QKKPnNa5xCXCbNQc8EGW9uiKKjn_cC1ywc6jE5v1hDo,513
 ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/core/__init__.py,sha256=RtYk6FdJxc7lxoSReRV1D7weTRYFu9ylhNNd3DyN904,4752
 ophyd_async/core/_derived_signal.py,sha256=TuZza_j3J1Bw4QSqBYB9Ta2FyQP5BycO3nSHVtJ890Q,13015
@@ -35,16 +35,16 @@ ophyd_async/epics/adaravis/__init__.py,sha256=ZQaJVQiwcQn9hUZADrYgBE1sDfFEwjhVBJ
 ophyd_async/epics/adaravis/_aravis.py,sha256=Ju2wuebz9_ovl-Kza39s5VQ1pV-Omt_BaIWKqP4kcGA,1315
 ophyd_async/epics/adaravis/_aravis_controller.py,sha256=WiFR7_FAAu6_88zG-yzGLsR9YcO4L6xR73Wnjw9n0i4,1908
 ophyd_async/epics/adaravis/_aravis_io.py,sha256=af5RxeXF2ligvAXwMNMKHA4QHTR_WmNFz-f18qD2dbg,855
-ophyd_async/epics/adcore/__init__.py,sha256=sDvQO3TshdXfDvLGqzsSNJT95Wk7tUAmOowDwB00Td0,1625
+ophyd_async/epics/adcore/__init__.py,sha256=L7muAe24Uo-ow0CoUTf_ooI2ntA1ZS57TTFimJeBQJ8,1579
 ophyd_async/epics/adcore/_core_detector.py,sha256=mRDaHgXCTZF-MIVsU1csoQx9jObutYDpMWayugx2-jI,2631
 ophyd_async/epics/adcore/_core_io.py,sha256=c1GqAUdv8lAQjklbKHtraLMhPOWEttDCsH9ow7M5I0U,7690
-ophyd_async/epics/adcore/_core_logic.py,sha256=IH7iOSVIsVj4e97ClhdBFpmdMkb8TznSaLkd3ohEhUs,8884
-ophyd_async/epics/adcore/_core_writer.py,sha256=6OEU8fcn7ATd3dml_aBZ_LmFgVGcdbNFyg1Sx2zqV7s,8522
+ophyd_async/epics/adcore/_core_logic.py,sha256=eMS9mIF6Ef2oXg1PmzMyyVviAbhujzYGbZZGq9vzf5k,8896
+ophyd_async/epics/adcore/_core_writer.py,sha256=pcnJhMHuWeZvlCyGSlW1QE_bNZjGbMuI8IsYEVHDtL0,8507
 ophyd_async/epics/adcore/_hdf_writer.py,sha256=AvCv_5dd2HdQoE12_CR6vH2hig2EdEIWklOu6CbPVlc,5816
 ophyd_async/epics/adcore/_jpeg_writer.py,sha256=VYpUWQGEjrKG2kiRGQZlBCPXVJ1BzWb9GyB9KhxPWgo,688
 ophyd_async/epics/adcore/_single_trigger.py,sha256=tFGLT1b_rZzAvbqWP-hyCccxJMRY26T5IER-VAqKXmc,1275
 ophyd_async/epics/adcore/_tiff_writer.py,sha256=197Ky9ltsJjUKNwl8_OAuoCe8dWIc7zCFs7wautwC7Y,689
-ophyd_async/epics/adcore/_utils.py,sha256=jMmZnyDwRDBq-N_x8qOWjW2RMN9uw2KuoAmukPbb404,4252
+ophyd_async/epics/adcore/_utils.py,sha256=eujvN4Tip_lIM2gYkbwkH_0cLRQSrQkylQOXUlpCo4k,3868
 ophyd_async/epics/adkinetix/__init__.py,sha256=A9xq3lGMrmza9lfukRixC0Up_kUDVFII8JguLr2x7Bw,308
 ophyd_async/epics/adkinetix/_kinetix.py,sha256=zZv0JZ8i1RSx7KBDn_1HGNOY0BoIP81mRK5TKq7d4eA,1302
 ophyd_async/epics/adkinetix/_kinetix_controller.py,sha256=UI-XcQpGj7jq-_e1ceoMOZkyfejwG6H5wX-Ntp_NJjg,1481
@@ -61,14 +61,14 @@ ophyd_async/epics/advimba/__init__.py,sha256=Onoe4N1DgjUZ0-00krm2-iJPXnNF8nPGs6I
 ophyd_async/epics/advimba/_vimba.py,sha256=4XlEnsJMGDzHLuYaIDUmaxx0gtOAehn5BKBZMUAzoHQ,1241
 ophyd_async/epics/advimba/_vimba_controller.py,sha256=v0av2bGnaJ01w9Igksupt2IlkuBEFlAeRCPOVma-Xa4,1980
 ophyd_async/epics/advimba/_vimba_io.py,sha256=cb2Nfp05fBZAcNVXpz-rqRIRS-TiZW5DPUJOmaFyAw0,1589
-ophyd_async/epics/core/__init__.py,sha256=8NoQxEEc2Ny_L9nrD2fnGSf_2gJr1wCR1LwUeLNcIJo,588
+ophyd_async/epics/core/__init__.py,sha256=q73i4aJ_0HApVNmf3eAw-q30XuazAyZW2MW5TXk-pOY,648
 ophyd_async/epics/core/_aioca.py,sha256=elNR5c2-YcDUoyzuvTEVURoqx92wkVoMDNjwjeZ0WmA,13136
 ophyd_async/epics/core/_epics_connector.py,sha256=S4z_wbj-aogVcjqCyUgjhcq5Y4gDC7y6wXbsSz2nODY,1918
 ophyd_async/epics/core/_epics_device.py,sha256=wGdR24I7GSPh3HmM7jsWKZhBZgt4IyLrCn4Ut7Wx_xo,510
 ophyd_async/epics/core/_p4p.py,sha256=uWh3oWPme74G4YfeJ6k8ZlHdKOwcf8Xp1J82b9aa_JI,16407
 ophyd_async/epics/core/_pvi_connector.py,sha256=nAReSiasZA3j_0f8XhuWVO4_ck0MrusnKR9Jg-RT-ok,5584
 ophyd_async/epics/core/_signal.py,sha256=qAEe8mgXRMgBTcxuwN-KDGSRtJTwrhygThTDe5vA3EQ,5916
-ophyd_async/epics/core/_util.py,sha256=G2kYfwsQ5iS3EgGrGuPA8bgC_PEN_XxO28oBurIqJFQ,2522
+ophyd_async/epics/core/_util.py,sha256=wcbZ6Qa2qqme6AlKAfxGI68EMEPEMJSl7BiDRz3mrEg,2820
 ophyd_async/epics/demo/__init__.py,sha256=WR2M3D8dbHcisJW2OIU2ManZu5SWez8ytZEp4jSBfDY,416
 ophyd_async/epics/demo/__main__.py,sha256=o6M0FSWduPHe2lN9yNEdsXb48NckSd54-XJGoLe20Pc,1116
 ophyd_async/epics/demo/_ioc.py,sha256=UtwTReKTR-1_tPIhdGBr7OxP_Vqi6xWyCcFABd9BYPY,1040
@@ -80,9 +80,9 @@ ophyd_async/epics/demo/motor.db,sha256=3xb6WTXo4crrvk-M8Y16G9pUidp27vD5vIKKBpLTU
 ophyd_async/epics/demo/point_detector.db,sha256=8kBa3XKpmfXCxetT4tq5_RFXa_XqS1Z2ZNzsa2AtLds,1366
 ophyd_async/epics/demo/point_detector_channel.db,sha256=FZ9H6HjqplhcF2jgimv_dT1nn-CBlfjs7Y--iCfHp5Y,632
 ophyd_async/epics/eiger/__init__.py,sha256=7kRqVzwoD8PVtp7Nj9iQWlgbLeoWE_8oiq-B0kixwTE,93
-ophyd_async/epics/eiger/_odin_io.py,sha256=vbIvMONlCyjI78tpyQGMIvWRX1Q2fASRRgln63N2lDY,5704
-ophyd_async/epics/pmac/__init__.py,sha256=RWqo5nYE2MMBdwvMxdeVG213MN38b9VPlpDHQWul8QQ,143
-ophyd_async/epics/pmac/_pmac_io.py,sha256=yMQpZ0Osh4l8VRd2aqWQE9ebJDfh5FwM_0pp1pe8-C0,3564
+ophyd_async/epics/eiger/_odin_io.py,sha256=JTnsADwNszWJoXpFmdcrZrCDc_RshGlM3Bg_aeUdrUg,6491
+ophyd_async/epics/pmac/__init__.py,sha256=QNL1imf90-4Jedsl1UU0bOF2SH5SWlmqAEVd2OD9_9I,163
+ophyd_async/epics/pmac/_pmac_io.py,sha256=3ngcNE5ytTW8TSnl34roqR9jtAKG0qlHjb44b0fd3Fk,3962
 ophyd_async/epics/testing/__init__.py,sha256=aTIv4D2DYrpnGco5RQF8QuLG1SfFkIlTyM2uYEKXltA,522
 ophyd_async/epics/testing/_example_ioc.py,sha256=uUmfMXV_Pd2SMFyb0y_4uTc6gkGRUqU1cJ-XQC2ROW8,3915
 ophyd_async/epics/testing/_utils.py,sha256=9gxpwaWX0HGtacu1LTupcw7viXN8G78RmuNciU_-cjs,1702
@@ -91,9 +91,9 @@ ophyd_async/epics/testing/test_records_pva.db,sha256=HJAJSvLtPWG5B5dKv8OZ0_hPJxR
 ophyd_async/fastcs/__init__.py,sha256=qlIM9-pjJ8yWfnzTM9-T9cw7zQLKjeeNROQTni5Dr6M,80
 ophyd_async/fastcs/core.py,sha256=pL_srtTrfuoBHUjDFpxES92owFq9M4Jve0Skk1oeuFA,517
 ophyd_async/fastcs/eiger/__init__.py,sha256=RxwOFjERKy5tUD_IDGCGuMh716FaZgCq7R9elPixBwo,312
-ophyd_async/fastcs/eiger/_eiger.py,sha256=nTK48deELmZn9x4Pd8QlyH6qYpbThbUTiXTwjfY6eB8,1106
+ophyd_async/fastcs/eiger/_eiger.py,sha256=X6KczJ9JMdZUEnlt2ozUhlL8Tk1MfzgmPIpVFXdisNw,1104
 ophyd_async/fastcs/eiger/_eiger_controller.py,sha256=Cucj-1M-1CaxSJxHZmHs3f_OXwtTIspcqUFhRNGzn_E,2361
-ophyd_async/fastcs/eiger/_eiger_io.py,sha256=KS1ppYt6PJvPpHiR2AaDaPAhkhYwC2ei8VuZnBBiBs8,1216
+ophyd_async/fastcs/eiger/_eiger_io.py,sha256=yNozTKX4CMoqIaFvyKJEs5RXXGJ4VITP_T4TIFHWRmc,1242
 ophyd_async/fastcs/odin/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
 ophyd_async/fastcs/panda/__init__.py,sha256=ugrScVm4HPQFc-d1kTAfZ5UUzW9T3SPgTi0OD2s8ZH0,1003
 ophyd_async/fastcs/panda/_block.py,sha256=SM7NaWCRwLz2Pl4wgjZMrDgx3ZLdGPTw6nU0bA-65yA,2394
@@ -145,8 +145,8 @@ ophyd_async/testing/_one_of_everything.py,sha256=Di0hPoKwrDOSsx50-2UdSHM2EbIKrPG
 ophyd_async/testing/_single_derived.py,sha256=5-HOTzgePcZ354NK_ssVpyIbJoJmKyjVQCxSwQXUC-4,2730
 ophyd_async/testing/_utils.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
 ophyd_async/testing/_wait_for_pending.py,sha256=YZAR48n-CW0GsPey3zFRzMJ4byDAr3HvMIoawjmTrHw,732
-ophyd_async-0.12.1.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.12.1.dist-info/METADATA,sha256=Vn04AobiRZJ4KZJ7Na9c3whRj0M1eEmWBbtWuW03i3I,7112
-ophyd_async-0.12.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ophyd_async-0.12.1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.12.1.dist-info/RECORD,,
+ophyd_async-0.12.3.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.12.3.dist-info/METADATA,sha256=iFBZBqmWlXn03HELUSW5OPBsJdcYikFX6w1BjfMdUP4,7114
+ophyd_async-0.12.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ophyd_async-0.12.3.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.12.3.dist-info/RECORD,,