ophyd-async 0.3a3__py3-none-any.whl → 0.3a5__py3-none-any.whl

ophyd_async/epics/motion/motor.py

@@ -1,10 +1,17 @@
 import asyncio
-import time
-from typing import Callable, List, Optional
+from dataclasses import replace
 
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, ConfigSignal, HintedSignal, StandardReadable
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+)
+from ophyd_async.core.signal import observe_value
+from ophyd_async.core.utils import WatcherUpdate
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -40,51 +47,47 @@ class Motor(StandardReadable, Movable, Stoppable):
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
+    async def _move(
+        self, new_position: float
+    ) -> tuple[WatcherUpdate[float], AsyncStatus]:
         self._set_success = True
-        start = time.monotonic()
         old_position, units, precision = await asyncio.gather(
             self.user_setpoint.get_value(),
             self.motor_egu.get_value(),
             self.precision.get_value(),
         )
-
-        def update_watchers(current_position: float):
-            for watcher in watchers:
-                watcher(
-                    name=self.name,
-                    current=current_position,
-                    initial=old_position,
-                    target=new_position,
-                    unit=units,
-                    precision=precision,
-                    time_elapsed=time.monotonic() - start,
-                )
-
-        self.user_readback.subscribe_value(update_watchers)
-        try:
-            await self.user_setpoint.set(new_position)
-        finally:
-            self.user_readback.clear_sub(update_watchers)
+        move_status = self.user_setpoint.set(new_position, wait=True)
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
+        return (
+            WatcherUpdate(
+                initial=old_position,
+                current=old_position,
+                target=new_position,
+                unit=units,
+                precision=precision,
+            ),
+            move_status,
+        )
 
-    def move(self, new_position: float, timeout: Optional[float] = None):
-        """Commandline only synchronous move of a Motor"""
-        from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
-
-        if in_bluesky_event_loop():
-            raise RuntimeError("Will deadlock run engine if run in a plan")
-        call_in_bluesky_event_loop(self._move(new_position), timeout)  # type: ignore
-
-    def set(self, new_position: float, timeout: Optional[float] = None) -> AsyncStatus:
-        watchers: List[Callable] = []
-        coro = asyncio.wait_for(self._move(new_position, watchers), timeout=timeout)
-        return AsyncStatus(coro, watchers)
+    @WatchableAsyncStatus.wrap
+    async def set(self, new_position: float, timeout: float | None = None):
+        update, move_status = await self._move(new_position)
+        async for current_position in observe_value(
+            self.user_readback, done_status=move_status
+        ):
+            if not self._set_success:
+                raise RuntimeError("Motor was stopped")
+            yield replace(
+                update,
+                name=self.name,
+                current=current_position,
+            )
 
     async def stop(self, success=False):
         self._set_success = success
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
-        status = self.motor_stop.trigger(wait=False)
-        await status
+        await self.motor_stop.trigger(wait=False)
+        # Trigger any callbacks
+        await self.user_readback._backend.put(await self.user_readback.get_value())

ophyd_async/epics/pvi/pvi.py

@@ -17,7 +17,7 @@ from typing import (
     get_type_hints,
 )
 
-from ophyd_async.core import Device, DeviceVector, SimSignalBackend
+from ophyd_async.core import Device, DeviceVector, SoftSignalBackend
 from ophyd_async.core.signal import Signal
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
 from ophyd_async.epics._backend._p4p import PvaSignalBackend
@@ -91,7 +91,7 @@ def _verify_common_blocks(entry: PVIEntry, common_device: Type[Device]):
         return
     common_sub_devices = get_type_hints(common_device)
     for sub_name, sub_device in common_sub_devices.items():
-        if sub_name in ("_name", "parent"):
+        if sub_name.startswith("_") or sub_name == "parent":
             continue
         assert entry.sub_entries
         device_t, is_optional = _strip_union(sub_device)
@@ -156,12 +156,12 @@ def _parse_type(
     return is_device_vector, is_signal, signal_dtype, device_cls
 
 
-def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
+def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
     device_t = stripped_type or type(device)
     sub_devices = (
         (field, field_type)
         for field, field_type in get_type_hints(device_t).items()
-        if field not in ("_name", "parent")
+        if not field.startswith("_") and field != "parent"
     )
 
     for device_name, device_cls in sub_devices:
@@ -175,23 +175,23 @@ def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
 
         if is_device_vector:
             if is_signal:
-                sub_device_1 = device_cls(SimSignalBackend(signal_dtype))
-                sub_device_2 = device_cls(SimSignalBackend(signal_dtype))
+                sub_device_1 = device_cls(SoftSignalBackend(signal_dtype))
+                sub_device_2 = device_cls(SoftSignalBackend(signal_dtype))
                 sub_device = DeviceVector({1: sub_device_1, 2: sub_device_2})
             else:
                 sub_device = DeviceVector({1: device_cls(), 2: device_cls()})
 
                 for sub_device_in_vector in sub_device.values():
-                    _sim_common_blocks(sub_device_in_vector, stripped_type=device_cls)
+                    _mock_common_blocks(sub_device_in_vector, stripped_type=device_cls)
 
             for value in sub_device.values():
                 value.parent = sub_device
         else:
             if is_signal:
-                sub_device = device_cls(SimSignalBackend(signal_dtype))
+                sub_device = device_cls(SoftSignalBackend(signal_dtype))
             else:
                 sub_device = getattr(device, device_name, device_cls())
-                _sim_common_blocks(sub_device, stripped_type=device_cls)
+                _mock_common_blocks(sub_device, stripped_type=device_cls)
 
         setattr(device, device_name, sub_device)
         sub_device.parent = device
@@ -269,16 +269,16 @@ def _set_device_attributes(entry: PVIEntry):
 
 
 async def fill_pvi_entries(
-    device: Device, root_pv: str, timeout=DEFAULT_TIMEOUT, sim=False
+    device: Device, root_pv: str, timeout=DEFAULT_TIMEOUT, mock=False
 ):
     """
     Fills a ``device`` with signals from a the ``root_pvi:PVI`` table.
 
     If the device names match with parent devices of ``device`` then types are used.
     """
-    if sim:
-        # set up sim signals for the common annotations
-        _sim_common_blocks(device)
+    if mock:
+        # set up mock signals for the common annotations
+        _mock_common_blocks(device)
     else:
         # check the pvi table for devices and fill the device with them
         root_entry = PVIEntry(

ophyd_async/epics/signal/__init__.py

@@ -1,8 +1,15 @@
-from .signal import epics_signal_r, epics_signal_rw, epics_signal_w, epics_signal_x
+from .signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+    epics_signal_w,
+    epics_signal_x,
+)
 
 __all__ = [
     "epics_signal_r",
     "epics_signal_rw",
+    "epics_signal_rw_rbv",
     "epics_signal_w",
     "epics_signal_x",
 ]

ophyd_async/panda/_hdf_panda.py

@@ -42,7 +42,7 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         )
 
     async def connect(
-        self, sim: bool = False, timeout: float = DEFAULT_TIMEOUT
+        self, mock: bool = False, timeout: float = DEFAULT_TIMEOUT
     ) -> None:
-        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, sim=sim)
-        await super().connect(sim=sim, timeout=timeout)
+        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, mock=mock)
+        await super().connect(mock=mock, timeout=timeout)

ophyd_async/planstubs/__init__.py

@@ -1,5 +1,9 @@
+from .ensure_connected import ensure_connected
 from .prepare_trigger_and_dets import (
     prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
 )
 
-__all__ = ["prepare_static_seq_table_flyer_and_detectors_with_same_trigger"]
+__all__ = [
+    "prepare_static_seq_table_flyer_and_detectors_with_same_trigger",
+    "ensure_connected",
+]

ophyd_async/planstubs/ensure_connected.py

@@ -0,0 +1,22 @@
+import bluesky.plan_stubs as bps
+
+from ophyd_async.core.device import Device
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, wait_for_connection
+
+
+def ensure_connected(
+    *devices: Device,
+    mock: bool = False,
+    timeout: float = DEFAULT_TIMEOUT,
+    force_reconnect=False,
+):
+    yield from bps.wait_for(
+        [
+            lambda: wait_for_connection(
+                **{
+                    device.name: device.connect(mock, timeout, force_reconnect)
+                    for device in devices
+                }
+            )
+        ]
+    )

ophyd_async/protocols.py

@@ -1,9 +1,20 @@
+from __future__ import annotations
+
 from abc import abstractmethod
-from typing import Dict, Protocol, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generic,
+    Protocol,
+    TypeVar,
+    runtime_checkable,
+)
 
 from bluesky.protocols import DataKey, HasName, Reading
 
-from ophyd_async.core.async_status import AsyncStatus
+if TYPE_CHECKING:
+    from ophyd_async.core.async_status import AsyncStatus
 
 
 @runtime_checkable
@@ -94,3 +105,22 @@ class AsyncStageable(Protocol):
         unstaging.
         """
         ...
+
+
+C = TypeVar("C", contravariant=True)
+
+
+class Watcher(Protocol, Generic[C]):
+    @staticmethod
+    def __call__(
+        *,
+        current: C,
+        initial: C,
+        target: C,
+        name: str | None,
+        unit: str | None,
+        precision: float | None,
+        fraction: float | None,
+        time_elapsed: float | None,
+        time_remaining: float | None,
+    ) -> Any: ...

ophyd_async/sim/demo/sim_motor.py

@@ -1,13 +1,18 @@
 import asyncio
 import time
-from typing import Callable, List, Optional
+from dataclasses import replace
 
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import StandardReadable
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.signal import soft_signal_r_and_backend, soft_signal_rw
+from ophyd_async.core.async_status import AsyncStatus, WatchableAsyncStatus
+from ophyd_async.core.signal import (
+    observe_value,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
 from ophyd_async.core.standard_readable import ConfigSignal, HintedSignal
+from ophyd_async.core.utils import WatcherUpdate
 
 
 class SimMotor(StandardReadable, Movable, Stoppable):
@@ -21,16 +26,16 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         - instant: bool: whether to move instantly, or with a delay
         """
         with self.add_children_as_readables(HintedSignal):
-            self.user_readback, self._user_readback = soft_signal_r_and_backend(
+            self.user_readback, self._user_readback_set = soft_signal_r_and_setter(
                 float, 0
             )
 
         with self.add_children_as_readables(ConfigSignal):
             self.velocity = soft_signal_rw(float, 1.0)
-            self.egu = soft_signal_rw(float, "mm")
+            self.egu = soft_signal_rw(str, "mm")
 
         self._instant = instant
-        self._move_task: Optional[asyncio.Task] = None
+        self._move_status: AsyncStatus | None = None
 
         # Define some signals
         self.user_setpoint = soft_signal_rw(float, 0)
@@ -44,21 +49,37 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         """
         Stop the motor if it is moving
         """
-        if self._move_task:
-            self._move_task.cancel()
-            self._move_task = None
+        if self._move_status:
+            self._move_status.task.cancel()
+            self._move_status = None
+
+        async def trigger_callbacks():
+            await self.user_readback._backend.put(
+                await self.user_readback._backend.get_value()
+            )
+
+        asyncio.create_task(trigger_callbacks())
 
         self._set_success = success
 
-    def set(self, new_position: float, timeout: Optional[float] = None) -> AsyncStatus:  # noqa: F821
+    @WatchableAsyncStatus.wrap
+    async def set(self, new_position: float, timeout: float | None = None):
         """
         Asynchronously move the motor to a new position.
         """
-        watchers: List[Callable] = []
-        coro = asyncio.wait_for(self._move(new_position, watchers), timeout=timeout)
-        return AsyncStatus(coro, watchers)
+        update, move_status = await self._move(new_position, timeout)
+        async for current_position in observe_value(
+            self.user_readback, done_status=move_status
+        ):
+            if not self._set_success:
+                raise RuntimeError("Motor was stopped")
+            yield replace(
+                update,
+                name=self.name,
+                current=current_position,
+            )
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
+    async def _move(self, new_position: float, timeout: float | None = None):
         """
         Start the motor moving to a new position.
 
@@ -67,6 +88,7 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         """
         self.stop()
         start = time.monotonic()
+        self._set_success = True
 
         current_position = await self.user_readback.get_value()
         distance = abs(new_position - current_position)
@@ -84,7 +106,7 @@ class SimMotor(StandardReadable, Movable, Stoppable):
                 # update position based on time elapsed
                 if time_elapsed >= travel_time:
                     # successfully reached our target position
-                    await self._user_readback.put(new_position)
+                    self._user_readback_set(new_position)
                     self._set_success = True
                     break
                 else:
@@ -92,27 +114,20 @@ class SimMotor(StandardReadable, Movable, Stoppable):
                         old_position + distance * time_elapsed / travel_time
                     )
 
-                await self._user_readback.put(current_position)
-
-                # notify watchers of the new position
-                for watcher in watchers:
-                    watcher(
-                        name=self.name,
-                        current=current_position,
-                        initial=old_position,
-                        target=new_position,
-                        unit=units,
-                        time_elapsed=time.monotonic() - start,
-                    )
+                self._user_readback_set(current_position)
 
                 # 10hz update loop
                 await asyncio.sleep(0.1)
 
-        # set up a task that updates the motor position at 10hz
-        self._move_task = asyncio.create_task(update_position())
-
-        try:
-            await self._move_task
-        finally:
-            if not self._set_success:
-                raise RuntimeError("Motor was stopped")
+        # set up a task that updates the motor position at ~10hz
+        self._move_status = AsyncStatus(asyncio.wait_for(update_position(), timeout))
+
+        return (
+            WatcherUpdate(
+                initial=old_position,
+                current=old_position,
+                target=new_position,
+                unit=units,
+            ),
+            self._move_status,
+        )

ophyd_async/sim/pattern_generator.py

@@ -23,8 +23,8 @@ from event_model import (
 )
 
 from ophyd_async.core import DirectoryInfo, DirectoryProvider
+from ophyd_async.core.mock_signal_backend import MockSignalBackend
 from ophyd_async.core.signal import SignalR, observe_value
-from ophyd_async.core.sim_signal_backend import SimSignalBackend
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
 
 # raw data path
@@ -158,8 +158,8 @@ class PatternGenerator:
         self.written_images_counter: int = 0
 
         # it automatically initializes to 0
-        self.signal_backend = SimSignalBackend(int)
-        self.sim_signal = SignalR(self.signal_backend)
+        self.signal_backend = MockSignalBackend(int)
+        self.mock_signal = SignalR(self.signal_backend)
         blob = np.array(
             generate_gaussian_blob(width=detector_width, height=detector_height)
             * MAX_UINT8_VALUE
@@ -220,7 +220,7 @@ class PatternGenerator:
     async def open_file(
         self, directory: DirectoryProvider, multiplier: int = 1
     ) -> Dict[str, DataKey]:
-        await self.sim_signal.connect()
+        await self.mock_signal.connect()
 
         self.target_path = self._get_new_path(directory)
 
@@ -314,5 +314,5 @@ class PatternGenerator:
     async def observe_indices_written(
         self, timeout=DEFAULT_TIMEOUT
     ) -> AsyncGenerator[int, None]:
-        async for num_captured in observe_value(self.sim_signal, timeout=timeout):
+        async for num_captured in observe_value(self.mock_signal, timeout=timeout):
             yield num_captured // self.multiplier

{ophyd_async-0.3a3.dist-info → ophyd_async-0.3a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a3
+Version: 0.3a5
 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: bluesky >=1.13.0a3
 Requires-Dist: event-model <1.21.0
 Requires-Dist: p4p
 Requires-Dist: pyyaml
+Requires-Dist: colorlog
 Provides-Extra: ca
 Requires-Dist: aioca >=1.6 ; extra == 'ca'
 Provides-Extra: dev
@@ -85,7 +86,6 @@ Requires-Dist: sphinx-design ; extra == 'dev'
 Requires-Dist: tox-direct ; extra == 'dev'
 Requires-Dist: types-mock ; extra == 'dev'
 Requires-Dist: types-pyyaml ; extra == 'dev'
-Requires-Dist: colorlog ; extra == 'dev'
 Provides-Extra: pva
 Requires-Dist: p4p ; extra == 'pva'
 

{ophyd_async-0.3a3.dist-info → ophyd_async-0.3a5.dist-info}/RECORD

@@ -1,64 +1,66 @@
 ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
 ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
-ophyd_async/_version.py,sha256=hJ-uDF6qfItINzjClbnbKB7a1O2myzhQQHmhtpj1sL0,408
+ophyd_async/_version.py,sha256=U12czQTgzf6ojb0_kN2Mdxwd3eohytfYDRR6gcj6mEw,408
 ophyd_async/log.py,sha256=DbMjt0bkfUOLHIinZYt0Q0FHZmCXXi5x8y0uFiEmqoQ,3587
-ophyd_async/protocols.py,sha256=48jqS78KAMvy6LmenL21ARoTAD8oOL9YdVmIlI0E0VA,2890
-ophyd_async/core/__init__.py,sha256=3GBJlwSkAH_zv4KhKLsxFxGPUuyOoJj2fTSbG6vOd6w,2496
+ophyd_async/protocols.py,sha256=EF2W9nfElV-0QNMYrX1zusL1PqDJR3kNsjlalR29j0I,3412
+ophyd_async/core/__init__.py,sha256=YMFc7rJhfq6waLMmHTCD6BVqUM_jM7joPGEoxUued7g,2893
 ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
-ophyd_async/core/async_status.py,sha256=-sfIf7VhwAP25kSVwKZjAIYOTROpfnh2jgkDw5_afSU,2801
-ophyd_async/core/detector.py,sha256=OkdaaJnj2v8DKF4k7VsTo8ReAvIzyFjBqbqdiYf7FBE,11179
-ophyd_async/core/device.py,sha256=Bm8u1wEN6PuJgCgis_msVRvfrO1_RumxAIMPag8k-cI,5813
+ophyd_async/core/async_status.py,sha256=h6IZUoSeGfuiMT_CAIR-nzHeTJH0srvSpiqOQtxHMnw,5229
+ophyd_async/core/detector.py,sha256=j4MRENoe3En4a-3gNpfQXvBgFC4besfcczoP98QOclc,11003
+ophyd_async/core/device.py,sha256=_0COEm9x35hmnBb-X5z_q8xnGwfzOgunAovtPWR5yik,7118
 ophyd_async/core/device_save_loader.py,sha256=RXA3dPUPihAR2ZGDStlGiA-TAsr_xqL0snsCjMsMnfA,9138
 ophyd_async/core/flyer.py,sha256=LfO3EQTW2zMeNqZh8TLXvE92E30Duds2RXskRYAdJ_4,2299
-ophyd_async/core/signal.py,sha256=S91oRS6E9zNNMV-Mpa7wqTt24IfFI22Vui9MhDQdxys,14523
+ophyd_async/core/mock_signal_backend.py,sha256=13BAbQG1OPC3o_fOFFQH4x1mPYLQ8Zf53WviRPXWDTM,2938
+ophyd_async/core/mock_signal_utils.py,sha256=umWf42HHWyUCYLVYnj5weh4pNBMpN1ElRTsxKsc4q_k,4287
+ophyd_async/core/signal.py,sha256=57z_-B9BDTCX0BwL63VnyBsBlBqWb6ltFLP9bPiYISE,16081
 ophyd_async/core/signal_backend.py,sha256=qDdWz8X4CWStuYknxcj4G76BLq4TzrAIyZO1NOEq9ao,1519
-ophyd_async/core/sim_signal_backend.py,sha256=jpCIp-93HraG_rbL1C2CYbZqyQMUpT1fnT4WX24Ihno,6057
+ophyd_async/core/soft_signal_backend.py,sha256=56zvcEi4c8n1yYbafTbp7X0VhSkhoehm3L8RBhu2fik,5596
 ophyd_async/core/standard_readable.py,sha256=uVG3vs3s7-Kzg5dRCtT4I2mhZPqwVGYy2dxNmaOpDVU,8980
-ophyd_async/core/utils.py,sha256=AVF5e42CVG_GaLoHJSI82iC4KAO60fb9fEJMISHBCNM,5043
+ophyd_async/core/utils.py,sha256=OMOpa-5QMAGQbbb0tFD4lRnyk0Fykq4aD2EOQbPt39c,5516
 ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/epics/_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/epics/_backend/_aioca.py,sha256=91BynQ2sXgK6WvjzgOmaxH7oHBNBHFVfpX3dOt4jo8o,8775
-ophyd_async/epics/_backend/_p4p.py,sha256=9TEDa1VzDwuOgPKl3jYOXQ9ysd60_Ri2ymepwdgZjNk,12202
-ophyd_async/epics/_backend/common.py,sha256=o0heeQEM7aP-QYCicwOEtNHs5c5OD6raR-5cTs9yRX0,840
-ophyd_async/epics/areadetector/__init__.py,sha256=zz6T9nLSBExYjllJGUVFWGsS7m3C680UHbWIjBl9Fn8,556
-ophyd_async/epics/areadetector/aravis.py,sha256=ujO82hYZ5D5GIaBhz0JNC2G5uVSgowY8xxsY2tunzi4,2277
+ophyd_async/epics/_backend/_aioca.py,sha256=cpPNZmRMi7FnAh2-3ec5uklLVFOqsmEmpI1nh5Ud1Ls,8794
+ophyd_async/epics/_backend/_p4p.py,sha256=lIKx7kQ2o8h3M4wPwrq8JBo8xuDnasJxpDH2ATVBY78,12257
+ophyd_async/epics/_backend/common.py,sha256=16mAuxDwA3eZFjUW8DHMabaW3CtEI0Qe8DLpP2xlW7Y,814
+ophyd_async/epics/areadetector/__init__.py,sha256=ViKzx-wUxkRyNR33wfpL11QB97o0J47_KMyI2C_NphI,510
+ophyd_async/epics/areadetector/aravis.py,sha256=YklN4V0loqUQBs4swVX304N49JIGPvrNOk8iA5EWofg,2127
 ophyd_async/epics/areadetector/kinetix.py,sha256=7rE2MLnz9DEmeiN9pCekDfpXuZ2DErnMajRp_9eoLZY,1359
 ophyd_async/epics/areadetector/pilatus.py,sha256=ki-BOBCEIiUD2wAtmujBIB1eX-nbXB4yMLJK_Q3opRM,1398
 ophyd_async/epics/areadetector/single_trigger_det.py,sha256=U92dqhioIfnve3jtCThq9gXBCdEzzqzY4ezk6rZV19g,1182
-ophyd_async/epics/areadetector/utils.py,sha256=dez54oElIkGMnhSM9qghToUB1opSqjdWTV2vhHCgRMA,3133
+ophyd_async/epics/areadetector/utils.py,sha256=p66UbVdKRFj6Sm1Qvm23kmlVyBMMqIvXFxA3x17YnSk,2824
 ophyd_async/epics/areadetector/vimba.py,sha256=IxG8KLzfb84iLtzf6ZoX9JikqZLP49lwkWu33bkDV9Y,1291
 ophyd_async/epics/areadetector/controllers/__init__.py,sha256=af58ci7X2z2s_FyUwR3IGQrws8q4TKcBw7vFyIS5FoI,217
 ophyd_async/epics/areadetector/controllers/ad_sim_controller.py,sha256=mthZ6WxajMEgUKptq3bnkIctbLhjzTagV66i1auB8cg,1587
-ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=vRiSexnFzijG8eEwowMAFIe730xFNMmgjjbXQVi4zrc,2394
+ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=CIfnZdq_NobO_UMC2TJoAfUEP9GlzZg5z5bz6Dn1DxY,2669
 ophyd_async/epics/areadetector/controllers/kinetix_controller.py,sha256=9QmydX85QOXfQL_UX49M9EQ2b2hUZPVzLxgGQn-A9Oc,1611
 ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=cd1CKkaXlwkpQ0I1VL7nN0U8R4VweTsa08WhvHYI4nY,2243
 ophyd_async/epics/areadetector/controllers/vimba_controller.py,sha256=Eh4Hr9rWgq1mKvE93JzgixntjPHxF3_07GTFqiOdZqE,2123
 ophyd_async/epics/areadetector/drivers/__init__.py,sha256=-Ib0Lz4fFQQmB7K0uFxMDvAerkLxadMQERH7lNAvrs4,495
-ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=ikfyNcZwJa5ah52DckjrBzkMMT_eDY1smM4XWfb6A6E,3689
-ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=Z96xXKfGJbLYehyy0wmP3mCW5lVRmdypmX-9U8cYbD8,5607
-ophyd_async/epics/areadetector/drivers/kinetix_driver.py,sha256=OPl42jZcUPs0l3iUr8Cgr3yswWcZ5MJEqhNS9LKv8Jg,640
-ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=fc3vNHqop9oLg-fvaU-diQNEV5U1qzA9vX2T8Hwy_E8,478
-ophyd_async/epics/areadetector/drivers/vimba_driver.py,sha256=jAoQJQV1fOwF-hwi-Y9YLYUuE00bhQ-tc8t7-K5-8VI,1546
+ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=cE7I-IsfQz3UR9yqghy4czAxHeHERTTKe080GB9sCFQ,3847
+ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=PmIygsVNoxxYHvZZzFAbAm2DXmXFc13nAzL_DJB6YSU,1464
+ophyd_async/epics/areadetector/drivers/kinetix_driver.py,sha256=yIV23BkGBJ4i0VskLiLL7AFbadCCR6Ch1UwUDJ9r2YM,743
+ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=0DsUu9vAPXDa2v8_V0f_kPjBtLu3y4_EkmFfFjYO4Gk,553
+ophyd_async/epics/areadetector/drivers/vimba_driver.py,sha256=J54VtWkOklfbSqZYxGWH1e6Uzm9_Gph_ZbCf9Zax0LU,1713
 ophyd_async/epics/areadetector/writers/__init__.py,sha256=tpPcrYd1hs8WS7C0gmCnR2EBwjE5RzCljI7WwZ2V_LM,191
 ophyd_async/epics/areadetector/writers/_hdfdataset.py,sha256=E0C9VgsPyY35h7k0mvcIhjsIVNavApLxizqNWlM388w,167
 ophyd_async/epics/areadetector/writers/_hdffile.py,sha256=YtUgOKX53m0TaFEGBW671qXqNuuEKxEyLV5Ein1fjvo,1799
 ophyd_async/epics/areadetector/writers/hdf_writer.py,sha256=e7EbusP3Ell-2npdLtDWcZ_kDIRidUwHeqcbeMx4mlU,5427
-ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=-wfaAJf7pPVHWJ5fEYX8ZR0tIq9-MjZAn_2MjXClL9I,1626
-ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=l0yBBEazviyFsWJv_4_sfGn_YM_Iyd0_SlMdAmUlXDU,871
-ophyd_async/epics/demo/__init__.py,sha256=D-jYrorqa5C3gLzIi2Hkn8f8uaE9wb5S-WX3YYuHV48,6052
+ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=whKDkvKnU1qiDym4xQq4Fd1jHEhtDu552xhhGSnB--w,1910
+ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=sG4XZAS_k065g88n9U3IJGtYI4PPHfyJMcVqh9hVAa4,979
+ophyd_async/epics/demo/__init__.py,sha256=8NetaM610KGlVa5QeM47c9KoWkG7GvXoepd8txf6MGU,5598
 ophyd_async/epics/demo/demo_ad_sim_detector.py,sha256=06y65yvaqXvL2rDocjYyLz9kTVzuwV-LeuPhEfExdOA,944
 ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
 ophyd_async/epics/demo/sensor.db,sha256=AVtiydrdtwAz2EFurO2Ult9SSRtre3r0akOBbL98LT0,554
 ophyd_async/epics/motion/__init__.py,sha256=tnmVRIwKa9PdN_xonJdAUD04UpEceh-hoD7XI62yDB0,46
-ophyd_async/epics/motion/motor.py,sha256=_670QAtrD4ZJI41inTOPEBEPxWviJH1iflI1-KLHz30,3745
+ophyd_async/epics/motion/motor.py,sha256=ZiyC0WvO9AAsv_FmYBaCmOYQ86yZIS3QnSxfyPUg5jE,3504
 ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
-ophyd_async/epics/pvi/pvi.py,sha256=hpn7GeO0xk_-UDoy42LIsi0adER9IZO3HPP2iu6Nmu4,11320
-ophyd_async/epics/signal/__init__.py,sha256=wb93RTqvSbGKVFQj8OHykbVLGLmwKHU72oi5xYu2UaY,188
+ophyd_async/epics/pvi/pvi.py,sha256=PJdY3rCRyIQbsbHDru-TJ-IVOItyaQwCQKAC0Widu6A,11363
+ophyd_async/epics/signal/__init__.py,sha256=JXKBSGpRL9y3auh27JRxsqDn_rBOXpJjtd4nCuDOX2g,261
 ophyd_async/epics/signal/_epics_transport.py,sha256=DEIL0iYUAWssysVEgWGu1fHSM1l-ATV2kjUgPtDN9LY,858
 ophyd_async/epics/signal/signal.py,sha256=M8ZVG_zLdYJfroCRX-u_w8c3yIhswSRw8e3RkW2szio,3166
 ophyd_async/panda/__init__.py,sha256=ZaD1nRgGKAGFGdpP1WWF-FnX3wcGuYqqq0QRZbaSBYQ,692
 ophyd_async/panda/_common_blocks.py,sha256=n0PPc1rar43oDSIA-yNubTc8fR5YCW1tyjQU58whsg0,1038
-ophyd_async/panda/_hdf_panda.py,sha256=zZxIdNIXHwjlZA-HTezQNfcCh98P2Pst6Pcld92rPLM,1414
+ophyd_async/panda/_hdf_panda.py,sha256=QjfZyYos0ZBlIqBiZ5UbyEd_wuh_cGzwV8QE9jvLiIY,1419
 ophyd_async/panda/_panda_controller.py,sha256=dIqcjmaIHVrki8UXSoDx46kk6I2Lhpe2o3sXNg5f-RQ,1238
 ophyd_async/panda/_table.py,sha256=dLoRP4zYNOkD_s0Vkp2wVYAwkjVG8nNdf8-FaXOTfPo,5655
 ophyd_async/panda/_trigger.py,sha256=tBH8uq_4o1ASG9yofVxq3tjf5v8LPzniDTRL4yjramI,1195
@@ -66,18 +68,19 @@ ophyd_async/panda/_utils.py,sha256=VHW5kPVISyEkmse_qQcyisBkkEwMO6GG2Ago-CH1AFA,4
 ophyd_async/panda/writers/__init__.py,sha256=xy7BguVQG4HNIDBfKPjMj0KQo1tptC9LbCpEuMcVGaM,70
 ophyd_async/panda/writers/_hdf_writer.py,sha256=_KlawqQHuWXLCvhGg1N6S4dQ8LhM88NbHsbXryxPvPA,7617
 ophyd_async/panda/writers/_panda_hdf_file.py,sha256=42iHaTax4JjOBpNC7d4nkNL9SM14OTnFPTIcXv2jg-4,1759
-ophyd_async/planstubs/__init__.py,sha256=G9B80_d87lnOThUsGbAYPqzMw9xDelq2TbS7dkB692o,188
+ophyd_async/planstubs/__init__.py,sha256=T2ICLREJv0uUgGRQbxk2w57TZ7jf7wYWB6TBY22cqnc,266
+ophyd_async/planstubs/ensure_connected.py,sha256=1MkDu8UqVRPHLnW9IXRn-QvKiG8-rCV8T4KDbjf9K6w,557
 ophyd_async/planstubs/prepare_trigger_and_dets.py,sha256=0c4XDAxVkSanyDKtaMda0VgPEbk2jM0geVzAx707DhI,1772
 ophyd_async/sim/__init__.py,sha256=ScjH1g7FMo5yPACfJRZE6xGBWCHU4bKDzNQk1tqObnA,366
-ophyd_async/sim/pattern_generator.py,sha256=cnHL9PEDrN1BTomLhGgPTWTnQIswNuYpU8AE9I1wi3g,10634
+ophyd_async/sim/pattern_generator.py,sha256=pvSk2zb82D08j2jiKAMqMAfRohGnYd_rpjUraLrCD6c,10640
 ophyd_async/sim/sim_pattern_detector_control.py,sha256=Ypz8IuRYAY2J243IhVbNyGr_Z-XtpJZ1qxma6NR3TgM,1838
 ophyd_async/sim/sim_pattern_detector_writer.py,sha256=ESpcVyHd1TP7Cojznv2hJAwLinu3XbgAiVKfX12FCII,1237
 ophyd_async/sim/sim_pattern_generator.py,sha256=fbcwWxTPYKLK33OzIY15vGylnonOO8HIudz1y_56GZU,1336
 ophyd_async/sim/demo/__init__.py,sha256=9mxKpslrL89cfSj4g3og8Br3O--pMj3hhWZS-Xu6kyA,56
-ophyd_async/sim/demo/sim_motor.py,sha256=uiMPV76JkFEVJkejECdpUNBygauaoPp11Ynb0N1TrD0,4075
-ophyd_async-0.3a3.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.3a3.dist-info/METADATA,sha256=Iw5ewVCui6t0KJzvVsbZbiMKu8V4WOwoNAFQ4fQtd1w,6301
-ophyd_async-0.3a3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ophyd_async-0.3a3.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
-ophyd_async-0.3a3.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.3a3.dist-info/RECORD,,
+ophyd_async/sim/demo/sim_motor.py,sha256=gtWYn_zs43XahpzNey0or2PDhoB78fZIVl767HnE-kU,4352
+ophyd_async-0.3a5.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.3a5.dist-info/METADATA,sha256=39ilqICk5TpmGcGnsJcpXzJjl0NV87VvpOPf2vUez80,6284
+ophyd_async-0.3a5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ophyd_async-0.3a5.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.3a5.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.3a5.dist-info/RECORD,,