ophyd-async 0.11__py3-none-any.whl → 0.12__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.11'
-__version_tuple__ = version_tuple = (0, 11)
+__version__ = version = '0.12'
+__version_tuple__ = version_tuple = (0, 12)

ophyd_async/core/_flyer.py

@@ -17,15 +17,15 @@ class FlyerController(ABC, Generic[T]):
 
     @abstractmethod
     async def prepare(self, value: T) -> Any:
-        """Move to the start of the flyscan."""
+        """Move to the start of the fly scan."""
 
     @abstractmethod
     async def kickoff(self):
-        """Start the flyscan."""
+        """Start the fly scan."""
 
     @abstractmethod
     async def complete(self):
-        """Block until the flyscan is done."""
+        """Block until the fly scan is done."""
 
     @abstractmethod
     async def stop(self):
@@ -101,7 +101,7 @@ class StandardFlyer(
         return AsyncStatus(self._prepare(value))
 
     async def _prepare(self, value: T) -> None:
-        # Move to start and setup the flyscan
+        # Move to start and setup the fly scan
         await self._trigger_logic.prepare(value)
 
     @AsyncStatus.wrap

ophyd_async/core/_signal.py

@@ -17,6 +17,7 @@ from bluesky.protocols import (
     Subscribable,
 )
 from event_model import DataKey
+from stamina import retry_context
 
 from ._device import Device, DeviceConnector
 from ._mock_signal_backend import MockSignalBackend
@@ -89,9 +90,11 @@ class Signal(Device, Generic[SignalDatatypeT]):
         backend: SignalBackend[SignalDatatypeT],
         timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
+        attempts: int = 1,
     ) -> None:
         super().__init__(name=name, connector=SignalConnector(backend))
         self._timeout = timeout
+        self._attempts = attempts
 
     @property
     def source(self) -> str:
@@ -144,7 +147,8 @@ class _SignalCache(Generic[SignalDatatypeT]):
         )
         self._reading = reading
         self._valid.set()
-        for function, want_value in self._listeners.items():
+        items = self._listeners.copy().items()
+        for function, want_value in items:
             self._notify(function, want_value)
 
     def _notify(
@@ -287,7 +291,16 @@ class SignalW(Signal[SignalDatatypeT], Movable):
             timeout = self._timeout
         source = self._connector.backend.source(self.name, read=False)
         self.log.debug(f"Putting value {value} to backend at source {source}")
-        await _wait_for(self._connector.backend.put(value, wait=wait), timeout, source)
+        async for attempt in retry_context(
+            on=asyncio.TimeoutError,
+            attempts=self._attempts,
+            wait_initial=0,
+            wait_jitter=0,
+        ):
+            with attempt:
+                await _wait_for(
+                    self._connector.backend.put(value, wait=wait), timeout, source
+                )
         self.log.debug(f"Successfully put value {value} to backend at source {source}")
 
 

ophyd_async/epics/core/_signal.py

@@ -94,6 +94,7 @@ def epics_signal_rw(
     write_pv: str | None = None,
     name: str = "",
     timeout: float = DEFAULT_TIMEOUT,
+    attempts: int = 1,
 ) -> SignalRW[SignalDatatypeT]:
     """Create a `SignalRW` backed by 1 or 2 EPICS PVs.
 
@@ -104,7 +105,7 @@ def epics_signal_rw(
     :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, read_pv, write_pv or read_pv)
-    return SignalRW(backend, name=name, timeout=timeout)
+    return SignalRW(backend, name=name, timeout=timeout, attempts=attempts)
 
 
 def epics_signal_rw_rbv(
@@ -113,6 +114,7 @@ def epics_signal_rw_rbv(
     read_suffix: str = "_RBV",
     name: str = "",
     timeout: float = DEFAULT_TIMEOUT,
+    attempts: int = 1,
 ) -> SignalRW[SignalDatatypeT]:
     """Create a `SignalRW` backed by 1 or 2 EPICS PVs, with a suffix on the readback pv.
 
@@ -128,7 +130,9 @@ def epics_signal_rw_rbv(
     else:
         read_pv = f"{write_pv}{read_suffix}"
 
-    return epics_signal_rw(datatype, read_pv, write_pv, name, timeout=timeout)
+    return epics_signal_rw(
+        datatype, read_pv, write_pv, name, timeout=timeout, attempts=attempts
+    )
 
 
 def epics_signal_r(
@@ -153,6 +157,7 @@ def epics_signal_w(
     write_pv: str,
     name: str = "",
     timeout: float = DEFAULT_TIMEOUT,
+    attempts: int = 1,
 ) -> SignalW[SignalDatatypeT]:
     """Create a `SignalW` backed by 1 EPICS PVs.
 
@@ -162,7 +167,7 @@ def epics_signal_w(
     :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, write_pv, write_pv)
-    return SignalW(backend, name=name, timeout=timeout)
+    return SignalW(backend, name=name, timeout=timeout, attempts=attempts)
 
 
 def epics_signal_x(

ophyd_async/epics/motor.py

@@ -108,7 +108,7 @@ class Motor(
 
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
-        """Move to the beginning of a suitable run-up distance ready for a flyscan."""
+        """Move to the beginning of a suitable run-up distance ready for a fly scan."""
         self._fly_info = value
 
         # Velocity, at which motor travels from start_position to end_position, in motor
@@ -147,7 +147,7 @@ class Motor(
         await self.velocity.set(abs(max_speed))
         await self.set(ramp_up_start_pos)
 
-        # Set velocity we will be using for the flyscan
+        # Set velocity we will be using for the fly scan
         await self.velocity.set(abs(value.velocity))
 
     @AsyncStatus.wrap

ophyd_async/fastcs/panda/_trigger.py

@@ -15,7 +15,7 @@ from ._table import SeqTable
 
 
 class SeqTableInfo(ConfinedModel):
-    """Info for the PandA `SeqTable` for flyscanning."""
+    """Info for the PandA `SeqTable` for fly scanning."""
 
     sequence_table: SeqTable = Field(strict=True)
     repeats: int = Field(ge=0)
@@ -23,7 +23,7 @@ class SeqTableInfo(ConfinedModel):
 
 
 class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
-    """For controlling the PandA `SeqTable` when flyscanning."""
+    """For controlling the PandA `SeqTable` when fly scanning."""
 
     def __init__(self, seq: SeqBlock) -> None:
         self.seq = seq
@@ -52,7 +52,7 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
 
 
 class PcompInfo(ConfinedModel):
-    """Info for the PandA `PcompBlock` for flyscanning."""
+    """Info for the PandA `PcompBlock` for fly scanning."""
 
     start_postion: int = Field(description="start position in counts")
     pulse_width: int = Field(description="width of a single pulse in counts", gt=0)
@@ -76,7 +76,7 @@ class PcompInfo(ConfinedModel):
 
 
 class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
-    """For controlling the PandA `PcompBlock` when flyscanning."""
+    """For controlling the PandA `PcompBlock` when fly scanning."""
 
     def __init__(self, pcomp: PcompBlock) -> None:
         self.pcomp = pcomp

ophyd_async/plan_stubs/__init__.py

@@ -1,11 +1,6 @@
 """Plan stubs for connecting, setting up and flying devices."""
 
 from ._ensure_connected import ensure_connected
-from ._fly import (
-    fly_and_collect,
-    prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
-    time_resolved_fly_and_collect_with_static_seq_table,
-)
 from ._nd_attributes import setup_ndattributes, setup_ndstats_sum
 from ._panda import apply_panda_settings
 from ._settings import (
@@ -17,9 +12,6 @@ from ._settings import (
 )
 
 __all__ = [
-    "fly_and_collect",
-    "prepare_static_seq_table_flyer_and_detectors_with_same_trigger",
-    "time_resolved_fly_and_collect_with_static_seq_table",
     "ensure_connected",
     "setup_ndattributes",
     "setup_ndstats_sum",

ophyd_async/plan_stubs/_fly.py

@@ -1,204 +0,0 @@
-import bluesky.plan_stubs as bps
-from bluesky.utils import short_uid
-
-from ophyd_async.core import (
-    DetectorTrigger,
-    StandardDetector,
-    StandardFlyer,
-    TriggerInfo,
-    in_micros,
-)
-from ophyd_async.fastcs.panda import (
-    PandaPcompDirection,
-    PcompInfo,
-    SeqTable,
-    SeqTableInfo,
-)
-
-
-def prepare_static_pcomp_flyer_and_detectors(
-    flyer: StandardFlyer[PcompInfo],
-    detectors: list[StandardDetector],
-    pcomp_info: PcompInfo,
-    trigger_info: TriggerInfo,
-):
-    """Prepare a hardware triggered flyable and one or more detectors.
-
-    Prepare a hardware triggered flyable and one or more detectors with the
-    same trigger.
-
-    """
-    for det in detectors:
-        yield from bps.prepare(det, trigger_info, wait=False, group="prep")
-    yield from bps.prepare(flyer, pcomp_info, wait=False, group="prep")
-    yield from bps.wait(group="prep")
-
-
-def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
-    flyer: StandardFlyer[SeqTableInfo],
-    detectors: list[StandardDetector],
-    number_of_frames: int,
-    exposure: float,
-    shutter_time: float,
-    repeats: int = 1,
-    period: float = 0.0,
-    frame_timeout: float | None = None,
-):
-    """Prepare a hardware triggered flyable and one or more detectors.
-
-    Prepare a hardware triggered flyable and one or more detectors with the
-    same trigger. This method constructs TriggerInfo and a static sequence
-    table from required parameters. The table is required to prepare the flyer,
-    and the TriggerInfo is required to prepare the detector(s).
-
-    This prepares all supplied detectors with the same trigger.
-
-    """
-    if not detectors:
-        raise ValueError("No detectors provided. There must be at least one.")
-
-    deadtime = max(det._controller.get_deadtime(exposure) for det in detectors)  # noqa: SLF001
-
-    trigger_info = TriggerInfo(
-        number_of_events=number_of_frames * repeats,
-        trigger=DetectorTrigger.CONSTANT_GATE,
-        deadtime=deadtime,
-        livetime=exposure,
-        exposure_timeout=frame_timeout,
-    )
-    trigger_time = number_of_frames * (exposure + deadtime)
-    pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
-
-    table = (
-        # Wait for pre-delay then open shutter
-        SeqTable.row(
-            time1=in_micros(pre_delay),
-            time2=in_micros(shutter_time),
-            outa2=True,
-        )
-        +
-        # Keeping shutter open, do N triggers
-        SeqTable.row(
-            repeats=number_of_frames,
-            time1=in_micros(exposure),
-            outa1=True,
-            outb1=True,
-            time2=in_micros(deadtime),
-            outa2=True,
-        )
-        +
-        # Add the shutter close
-        SeqTable.row(time2=in_micros(shutter_time))
-    )
-
-    table_info = SeqTableInfo(sequence_table=table, repeats=repeats)
-
-    for det in detectors:
-        yield from bps.prepare(det, trigger_info, wait=False, group="prep")
-    yield from bps.prepare(flyer, table_info, wait=False, group="prep")
-    yield from bps.wait(group="prep")
-
-
-def fly_and_collect(
-    stream_name: str,
-    flyer: StandardFlyer[SeqTableInfo] | StandardFlyer[PcompInfo],
-    detectors: list[StandardDetector],
-):
-    """Kickoff, complete and collect with a flyer and multiple detectors.
-
-    This stub takes a flyer and one or more detectors that have been prepared. It
-    declares a stream for the detectors, then kicks off the detectors and the flyer.
-    The detectors are collected until the flyer and detectors have completed.
-
-    """
-    yield from bps.declare_stream(*detectors, name=stream_name, collect=True)
-    yield from bps.kickoff(flyer, wait=True)
-    for detector in detectors:
-        yield from bps.kickoff(detector)
-
-    # collect_while_completing
-    group = short_uid(label="complete")
-
-    yield from bps.complete(flyer, wait=False, group=group)
-    for detector in detectors:
-        yield from bps.complete(detector, wait=False, group=group)
-
-    done = False
-    while not done:
-        try:
-            yield from bps.wait(group=group, timeout=0.5)
-        except TimeoutError:
-            pass
-        else:
-            done = True
-        yield from bps.collect(
-            *detectors,
-            return_payload=False,
-            name=stream_name,
-        )
-    yield from bps.wait(group=group)
-
-
-def fly_and_collect_with_static_pcomp(
-    stream_name: str,
-    flyer: StandardFlyer[PcompInfo],
-    detectors: list[StandardDetector],
-    number_of_pulses: int,
-    pulse_width: int,
-    rising_edge_step: int,
-    direction: PandaPcompDirection,
-    trigger_info: TriggerInfo,
-):
-    # Set up scan and prepare trigger
-    pcomp_info = PcompInfo(
-        start_postion=0,
-        pulse_width=pulse_width,
-        rising_edge_step=rising_edge_step,
-        number_of_pulses=number_of_pulses,
-        direction=direction,
-    )
-    yield from prepare_static_pcomp_flyer_and_detectors(
-        flyer, detectors, pcomp_info, trigger_info
-    )
-
-    # Run the fly scan
-    yield from fly_and_collect(stream_name, flyer, detectors)
-
-
-def time_resolved_fly_and_collect_with_static_seq_table(
-    stream_name: str,
-    flyer: StandardFlyer[SeqTableInfo],
-    detectors: list[StandardDetector],
-    number_of_frames: int,
-    exposure: float,
-    shutter_time: float,
-    repeats: int = 1,
-    period: float = 0.0,
-    frame_timeout: float | None = None,
-):
-    """Run a scan wth a flyer and multiple detectors.
-
-    The stub demonstrates the standard basic flow for a flyscan:
-
-    - Prepare the flyer and detectors with a trigger
-    - Fly and collect:
-       - Declare the stream and kickoff the scan
-       - Collect while completing
-
-    This needs to be used in a plan that instantates detectors and a flyer,
-    stages/unstages the devices, and opens and closes the run.
-
-    """
-    # Set up scan and prepare trigger
-    yield from prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
-        flyer,
-        detectors,
-        number_of_frames=number_of_frames,
-        exposure=exposure,
-        shutter_time=shutter_time,
-        repeats=repeats,
-        period=period,
-        frame_timeout=frame_timeout,
-    )
-    # Run the fly scan
-    yield from fly_and_collect(stream_name, flyer, detectors)

ophyd_async/testing/__init__.py

@@ -11,6 +11,7 @@ from ._assert import (
     assert_emitted,
     assert_reading,
     assert_value,
+    partial_reading,
 )
 from ._mock_signal_utils import (
     callback_on_mock_put,
@@ -47,6 +48,7 @@ __all__ = [
     "assert_configuration",
     "assert_describe_signal",
     "assert_emitted",
+    "partial_reading",
     # Mocking utilities
     "get_mock",
     "set_mock_value",

ophyd_async/testing/_assert.py

@@ -21,6 +21,15 @@ from ophyd_async.core import (
 from ._utils import T
 
 
+def partial_reading(val: Any) -> dict[str, Any]:
+    """Helper function for building expected reading or configuration dicts.
+
+    :param val: Value to be wrapped in dict with "value" as the key.
+    :return: The dict that has wrapped the val with key "value".
+    """
+    return {"value": val}
+
+
 def approx_value(value: Any):
     """Allow any value to be compared to another in tests.
 
@@ -45,14 +54,18 @@ async def assert_value(signal: SignalR[SignalDatatypeT], value: Any) -> None:
 async def assert_reading(
     readable: AsyncReadable,
     expected_reading: Mapping[str, Mapping[str, Any]],
+    full_match: bool = True,
 ) -> None:
     """Assert that a readable Device has the given reading.
 
     :param readable: Device with an async ``read()`` method to get the reading from.
     :param expected_reading: The expected reading from the readable.
+    :param full_match: if expected_reading keys set is same as actual keys set.
+        true: exact match
+        false: expected_reading keys is subset of actual reading keys
     """
     actual_reading = await readable.read()
-    _assert_readings_approx_equal(expected_reading, actual_reading)
+    _assert_readings_approx_equal(expected_reading, actual_reading, full_match)
 
 
 def _approx_reading(expected: Mapping[str, Any], actual: Reading) -> Reading:
@@ -69,16 +82,26 @@ def _approx_reading(expected: Mapping[str, Any], actual: Reading) -> Reading:
 
 
 def _assert_readings_approx_equal(
-    expected: Mapping[str, Mapping[str, Any]], actual: Mapping[str, Reading]
+    expected: Mapping[str, Mapping[str, Any]],
+    actual: Mapping[str, Reading],
+    full_match: bool = True,
 ):
-    assert actual == {
-        k: _approx_reading(v, actual[k]) for k, v in expected.items() if k in actual
+    # expand the expected keys to include actual if we allow partial matches
+    if not full_match:
+        expected = dict(actual, **expected)
+    # now make them approximate if they are in actual so we get a nicer diff
+    approx_expected = {
+        k: _approx_reading(v, actual[k]) if k in actual else v
+        for k, v in expected.items()
     }
+    # now we can compare them
+    assert actual == approx_expected
 
 
 async def assert_configuration(
     configurable: AsyncConfigurable,
-    configuration: dict[str, dict[str, Any]],
+    expected_configuration: dict[str, dict[str, Any]],
+    full_match: bool = True,
 ) -> None:
     """Assert that a configurable Device has the given configuration.
 
@@ -86,9 +109,14 @@ async def assert_configuration(
         Device with an async ``read_configuration()`` method to get the
         configuration from.
     :param configuration: The expected configuration from the configurable.
+    :param full_match: if expected_reading keys set is same as actual keys set.
+        true: exact match
+        false: expected_reading keys is subset of actual reading keys
     """
     actual_configuration = await configurable.read_configuration()
-    _assert_readings_approx_equal(configuration, actual_configuration)
+    _assert_readings_approx_equal(
+        expected_configuration, actual_configuration, full_match
+    )
 
 
 async def assert_describe_signal(signal: SignalR, /, **metadata):

{ophyd_async-0.11.dist-info → ophyd_async-0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.11
+Version: 0.12
 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
@@ -48,6 +48,7 @@ Requires-Dist: pyyaml
 Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
+Requires-Dist: stamina>=23.1.0
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
@@ -120,7 +121,7 @@ The main differences from ophyd sync are:
 - Support for [EPICS][] PVA and [Tango][] as well as the traditional EPICS CA
 - Better library support for splitting the logic from the hardware interface to avoid complex class heirarchies
 
-It was written with the aim of implementing flyscanning in a generic and extensible way with highly customizable devices like PandABox and the Delta Tau PMAC products. Using async code makes it possible to do the "put 3 PVs in parallel, then get from another PV" logic that is common in flyscanning without the performance and complexity overhead of multiple threads.
+It was written with the aim of implementing fly scanning in a generic and extensible way with highly customizable devices like PandABox and the Delta Tau PMAC products. Using async code makes it possible to do the "put 3 PVs in parallel, then get from another PV" logic that is common in fly scanning without the performance and complexity overhead of multiple threads.
 
 Devices from both ophyd sync and ophyd-async can be used in the same RunEngine and even in the same scan. This allows a per-device migration where devices are reimplemented in ophyd-async one by one.
 

{ophyd_async-0.11.dist-info → ophyd_async-0.12.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=JQGWKvS8mTtWQI0a0XtjLQOyFpNGX620dVCNBNQBiDE,508
+ophyd_async/_version.py,sha256=DJRqD0JYfzL1dCvH3-tt5p9TxBGyEU8MKFd2lrz6Yqw,508
 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
@@ -9,7 +9,7 @@ ophyd_async/core/_derived_signal_backend.py,sha256=PYyyont_nUR9LBC9eqVwueHCMwLJf
 ophyd_async/core/_detector.py,sha256=x1o-eSkvemQ-fTk47440owkTmYhuckA2ILNOCoJlHCY,15201
 ophyd_async/core/_device.py,sha256=lSm8FBul9NTn9VO0rsAlV9pctJyUsMdU2ztEf5CqH5M,14716
 ophyd_async/core/_device_filler.py,sha256=MDz8eQQ-eEAwo-UEMxfqPfpcBuMG01tLCGR6utwVnmE,14825
-ophyd_async/core/_flyer.py,sha256=Rvoi2AzPwbz-dnt3WlpfJTodgZDiK5cusbutfkbr_8A,3453
+ophyd_async/core/_flyer.py,sha256=8zKyU5aQOr_t59GIUwsYeb8NSabdvBp0swwuRe4v5VQ,3457
 ophyd_async/core/_hdf_dataset.py,sha256=qh4QMJAXuOUQUciLXdMTX9yPnmWp5l-ugGCrJWUXQDQ,2954
 ophyd_async/core/_log.py,sha256=DxKR4Nz3SgTaTzKBZWqt-w48yT8WUAr_3Qr223TEWRw,3587
 ophyd_async/core/_mock_signal_backend.py,sha256=SPdCbVWss6-iL9C3t9u0IvR_Ln9JeDypVd18WlivdjE,3156
@@ -17,7 +17,7 @@ ophyd_async/core/_protocol.py,sha256=wQ_snxhTprHqEjQb1HgFwBljwolMY6A8C3xgV1PXwdU
 ophyd_async/core/_providers.py,sha256=1XuLUw9sT1pKMfH_PsDEpIi1gulla7NfPSp3IR3KfEA,7545
 ophyd_async/core/_readable.py,sha256=iBo1YwA5bsAbzLbznvmSnzKDWUuGkLh850Br3BXsgeU,11707
 ophyd_async/core/_settings.py,sha256=_ZccbXKP7j5rG6-bMKk7aaLr8hChdRDAPY_YSR71XXM,4213
-ophyd_async/core/_signal.py,sha256=XXbcitQ6pmQnZUjTfsAvkWXIMS-ybGTRImYBbHAaPR0,27837
+ophyd_async/core/_signal.py,sha256=wKbDJYpN7zWgRf_jAARFqZwCGXcdzPRDNXwvjGUR6dw,28217
 ophyd_async/core/_signal_backend.py,sha256=PvwTbbSVEGqM-2s5BNRrKGwM_MiYL71qMxYAgyZ7wRM,6930
 ophyd_async/core/_soft_signal_backend.py,sha256=zrE7H2ojHY6oQBucLkFgukszrkdvbIZuavLjEUqc_xM,6227
 ophyd_async/core/_status.py,sha256=h4TtWFM7wFtpxxyAYYSITgcVzArYZdYBHbya6qIX5t0,6553
@@ -25,7 +25,7 @@ ophyd_async/core/_table.py,sha256=ai-_W-_WMZcy9f69BDYRv9vjVl-AVeOPN_uHYoGCSsc,69
 ophyd_async/core/_utils.py,sha256=fePvt3g7eQ6CRQcMVkMeqxcbvYZboZ2sf1fVVZL-26M,12450
 ophyd_async/core/_yaml_settings.py,sha256=Qojhku9l5kPSkTnEylCRWTe0gpw6S_XP5av5dPpqFgQ,2089
 ophyd_async/epics/__init__.py,sha256=ou4yEaH9VZHz70e8oM614-arLMQvUfQyXhRJsnEpWn8,60
-ophyd_async/epics/motor.py,sha256=pdXaXo4kpJAEZGXXtBxbNdnfPppqyplpP0jFsdyWVkA,8473
+ophyd_async/epics/motor.py,sha256=UFolYxuaePnWNJNOFzgI-He4kBTHhJqaTywtqFFSmsk,8475
 ophyd_async/epics/signal.py,sha256=0A-supp9ajr63O6aD7F9oG0-Q26YmRjk-ZGh57-jo1Y,239
 ophyd_async/epics/adandor/__init__.py,sha256=dlitllrAdhvh16PAcVMUSSEytTDNMu6_HuYk8KD1EoY,343
 ophyd_async/epics/adandor/_andor.py,sha256=SxAIP9OLefUqKcxrxhjNzil5D8-59Ps0vADdR6scO44,1281
@@ -67,7 +67,7 @@ ophyd_async/epics/core/_epics_connector.py,sha256=S4z_wbj-aogVcjqCyUgjhcq5Y4gDC7
 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=2Cp5f5Xb2junnVigypjb3hWu4MuMmbrcHOBgPl5Mhv4,5776
+ophyd_async/epics/core/_signal.py,sha256=qAEe8mgXRMgBTcxuwN-KDGSRtJTwrhygThTDe5vA3EQ,5916
 ophyd_async/epics/core/_util.py,sha256=G2kYfwsQ5iS3EgGrGuPA8bgC_PEN_XxO28oBurIqJFQ,2522
 ophyd_async/epics/demo/__init__.py,sha256=WR2M3D8dbHcisJW2OIU2ManZu5SWez8ytZEp4jSBfDY,416
 ophyd_async/epics/demo/__main__.py,sha256=o6M0FSWduPHe2lN9yNEdsXb48NckSd54-XJGoLe20Pc,1116
@@ -100,11 +100,11 @@ ophyd_async/fastcs/panda/_block.py,sha256=SM7NaWCRwLz2Pl4wgjZMrDgx3ZLdGPTw6nU0bA
 ophyd_async/fastcs/panda/_control.py,sha256=xtW3dH_MLQoycgP-4vJtYx1M9alHjWo13iu9UFTgwzY,1306
 ophyd_async/fastcs/panda/_hdf_panda.py,sha256=tL_OWHxlMQcMZGq9sxHLSeag6hP9MRIbTPn1W0u0iNI,1237
 ophyd_async/fastcs/panda/_table.py,sha256=maKGoKypEuYqTSVWGgDO6GMEKOtlDm9Dn5YiYdBzu6c,2486
-ophyd_async/fastcs/panda/_trigger.py,sha256=X3FV51zNq3aADeSj-mwghf_NH72_25BreTPvjkOiQTE,3400
+ophyd_async/fastcs/panda/_trigger.py,sha256=TLd0ST-ZgsCGpONGUe76qHOaH74TlZNIGNkh-10eRa8,3404
 ophyd_async/fastcs/panda/_writer.py,sha256=9cXDrfzj_e8LyGoG7kvgmftt8D_TS6r0fnlO8uR1fHw,6298
-ophyd_async/plan_stubs/__init__.py,sha256=2ngpkB4wwqlx1dn9JPSHjQdbyWLmY6n-3XVh3RDE8-g,939
+ophyd_async/plan_stubs/__init__.py,sha256=sRe1Jna_6i7aKjE3pPzsP4iNMWeWdtiptLnOq9pov9M,619
 ophyd_async/plan_stubs/_ensure_connected.py,sha256=YR6VRj7koccJ4x35NV-Ugl4ZbxgAoGN9PjVIjhv0gpw,894
-ophyd_async/plan_stubs/_fly.py,sha256=2xFae3b3bCux_1wmwKIF1tJx1vjg2JJfJ8iQ1aUExAs,6234
+ophyd_async/plan_stubs/_fly.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/plan_stubs/_nd_attributes.py,sha256=kwzyUSeidUH714gaZQtJLxCgDZtmIRyyoKBBRbvqg38,2350
 ophyd_async/plan_stubs/_panda.py,sha256=5_Mf9kGzNjXpf_YscpCUE8tgq284nOHWCG7o_LNFfII,463
 ophyd_async/plan_stubs/_settings.py,sha256=e3dGVSUV-Htay_9fKXyQTAQLdjunetGI3OBYp_oC_FY,5574
@@ -137,16 +137,16 @@ ophyd_async/tango/demo/_tango/__init__.py,sha256=FfONT7vM49nNo3a1Lv-LcMZO9EHv6bv
 ophyd_async/tango/demo/_tango/_servers.py,sha256=putvERDyibibaTbhdWyqZB_axj2fURXqzDsZb9oSW14,2991
 ophyd_async/tango/testing/__init__.py,sha256=SYXPAS00ny3jlUMOJKpaewO4ljPjK1_z1smj7IfsBQg,148
 ophyd_async/tango/testing/_one_of_everything.py,sha256=tsxWgy2f_m9f0FH4XCVO_I8OtEquKbJQZbr4KaXMJL4,6571
-ophyd_async/testing/__init__.py,sha256=f53HUj2hpIfrza9OlcOpHmq5wnziQNwixawAK4F1xgc,1698
+ophyd_async/testing/__init__.py,sha256=jDBzUAHGDMfkhd-_9u0CJWEq0E0sPrIGGlLmVzEyxY8,1742
 ophyd_async/testing/__pytest_assert_rewrite.py,sha256=_SU2UfChPgEf7CFY7aYH2B7MLp-07_qYnVLyu6QtDL8,129
-ophyd_async/testing/_assert.py,sha256=FrMgMfo-ABq_cMT-hJmoaTxhAY4TwAvGe4ae1SF1rME,7657
+ophyd_async/testing/_assert.py,sha256=zDTJh7QPhaJpzhnuFuejGKTKbKAs7ZNKx3sVsXBMrTU,8758
 ophyd_async/testing/_mock_signal_utils.py,sha256=d-n_923ii59-ae9TbqVuIK9MAJpDmu0k47fzgJLj8t8,5195
 ophyd_async/testing/_one_of_everything.py,sha256=Di0hPoKwrDOSsx50-2UdSHM2EbIKrPG9s0Vp11nE9V8,4773
 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.11.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.11.dist-info/METADATA,sha256=0H2kxSQoFHWEs8JMhMkrrQRw49Bh0wV4ulAnW5pZ6Ks,7077
-ophyd_async-0.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ophyd_async-0.11.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.11.dist-info/RECORD,,
+ophyd_async-0.12.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.12.dist-info/METADATA,sha256=mpFROvfJrpnj_A-CMYhK4YST2f8ZrkvNkvWg9dVFNVc,7110
+ophyd_async-0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ophyd_async-0.12.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.12.dist-info/RECORD,,