ophyd-async 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

ophyd_async/epics/areadetector/writers/_hdffile.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+from typing import Iterator, List
+
+from event_model import StreamDatum, StreamResource, compose_stream_resource
+
+from ophyd_async.core import DirectoryInfo
+
+from ._hdfdataset import _HDFDataset
+
+
+class _HDFFile:
+    """
+    :param directory_info: Contains information about how to construct a StreamResource
+    :param full_file_name: Absolute path to the file to be written
+    :param datasets: Datasets to write into the file
+    """
+
+    def __init__(
+        self,
+        directory_info: DirectoryInfo,
+        full_file_name: Path,
+        datasets: List[_HDFDataset],
+    ) -> None:
+        self._last_emitted = 0
+        self._bundles = [
+            compose_stream_resource(
+                spec="AD_HDF5_SWMR_SLICE",
+                root=str(directory_info.root),
+                data_key=ds.name,
+                resource_path=str(full_file_name.relative_to(directory_info.root)),
+                resource_kwargs={
+                    "path": ds.path,
+                    "multiplier": ds.multiplier,
+                    "timestamps": "/entry/instrument/NDAttributes/NDArrayTimeStamp",
+                },
+            )
+            for ds in datasets
+        ]
+
+    def stream_resources(self) -> Iterator[StreamResource]:
+        for bundle in self._bundles:
+            yield bundle.stream_resource_doc
+
+    def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
+        # Indices are relative to resource
+        if indices_written > self._last_emitted:
+            indices = {
+                "start": self._last_emitted,
+                "stop": indices_written,
+            }
+            self._last_emitted = indices_written
+            for bundle in self._bundles:
+                yield bundle.compose_stream_datum(indices)
+        return None

ophyd_async/epics/areadetector/writers/hdf_writer.py

@@ -0,0 +1,142 @@
+import asyncio
+from pathlib import Path
+from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
+
+from bluesky.protocols import DataKey, Hints, StreamAsset
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DetectorWriter,
+    DirectoryProvider,
+    NameProvider,
+    ShapeProvider,
+    set_and_wait_for_value,
+    wait_for_value,
+)
+from ophyd_async.core.signal import observe_value
+
+from ._hdfdataset import _HDFDataset
+from ._hdffile import _HDFFile
+from .nd_file_hdf import FileWriteMode, NDFileHDF
+
+
+class HDFWriter(DetectorWriter):
+    def __init__(
+        self,
+        hdf: NDFileHDF,
+        directory_provider: DirectoryProvider,
+        name_provider: NameProvider,
+        shape_provider: ShapeProvider,
+        **scalar_datasets_paths: str,
+    ) -> None:
+        self.hdf = hdf
+        self._directory_provider = directory_provider
+        self._name_provider = name_provider
+        self._shape_provider = shape_provider
+        self._scalar_datasets_paths = scalar_datasets_paths
+        self._capture_status: Optional[AsyncStatus] = None
+        self._datasets: List[_HDFDataset] = []
+        self._file: Optional[_HDFFile] = None
+        self._multiplier = 1
+
+    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+        self._file = None
+        info = self._directory_provider()
+        file_path = str(info.root / info.resource_dir)
+        await asyncio.gather(
+            self.hdf.num_extra_dims.set(0),
+            self.hdf.lazy_open.set(True),
+            self.hdf.swmr_mode.set(True),
+            # See https://github.com/bluesky/ophyd-async/issues/122
+            self.hdf.file_path.set(file_path),
+            self.hdf.file_name.set(f"{info.prefix}{self.hdf.name}{info.suffix}"),
+            self.hdf.file_template.set("%s/%s.h5"),
+            self.hdf.file_write_mode.set(FileWriteMode.stream),
+            # Never use custom xml layout file but use the one defined
+            # in the source code file NDFileHDF5LayoutXML.cpp
+            self.hdf.xml_file_name.set(""),
+        )
+
+        assert (
+            await self.hdf.file_path_exists.get_value()
+        ), f"File path {file_path} for hdf plugin does not exist"
+
+        # Overwrite num_capture to go forever
+        await self.hdf.num_capture.set(0)
+        # Wait for it to start, stashing the status that tells us when it finishes
+        self._capture_status = await set_and_wait_for_value(self.hdf.capture, True)
+        name = self._name_provider()
+        detector_shape = tuple(await self._shape_provider())
+        self._multiplier = multiplier
+        outer_shape = (multiplier,) if multiplier > 1 else ()
+        # Add the main data
+        self._datasets = [
+            _HDFDataset(name, "/entry/data/data", detector_shape, multiplier)
+        ]
+        # And all the scalar datasets
+        for ds_name, ds_path in self._scalar_datasets_paths.items():
+            self._datasets.append(
+                _HDFDataset(
+                    f"{name}-{ds_name}",
+                    f"/entry/instrument/NDAttributes/{ds_path}",
+                    (),
+                    multiplier,
+                )
+            )
+        describe = {
+            ds.name: DataKey(
+                source=self.hdf.full_file_name.source,
+                shape=outer_shape + tuple(ds.shape),
+                dtype="array" if ds.shape else "number",
+                external="STREAM:",
+            )
+            for ds in self._datasets
+        }
+        return describe
+
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        """Wait until a specific index is ready to be collected"""
+        async for num_captured in observe_value(self.hdf.num_captured, timeout):
+            yield num_captured // self._multiplier
+
+    async def get_indices_written(self) -> int:
+        num_captured = await self.hdf.num_captured.get_value()
+        return num_captured // self._multiplier
+
+    async def collect_stream_docs(
+        self, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
+        # TODO: fail if we get dropped frames
+        await self.hdf.flush_now.set(True)
+        if indices_written:
+            if not self._file:
+                path = Path(await self.hdf.full_file_name.get_value())
+                self._file = _HDFFile(
+                    self._directory_provider(),
+                    # See https://github.com/bluesky/ophyd-async/issues/122
+                    path,
+                    self._datasets,
+                )
+                # stream resource says "here is a dataset",
+                # stream datum says "here are N frames in that stream resource",
+                # you get one stream resource and many stream datums per scan
+
+                for doc in self._file.stream_resources():
+                    yield "stream_resource", doc
+            for doc in self._file.stream_data(indices_written):
+                yield "stream_datum", doc
+
+    async def close(self):
+        # Already done a caput callback in _capture_status, so can't do one here
+        await self.hdf.capture.set(0, wait=False)
+        await wait_for_value(self.hdf.capture, 0, DEFAULT_TIMEOUT)
+        if self._capture_status:
+            # We kicked off an open, so wait for it to return
+            await self._capture_status
+
+    @property
+    def hints(self) -> Hints:
+        return {"fields": [self._name_provider()]}

ophyd_async/epics/areadetector/writers/nd_file_hdf.py

@@ -0,0 +1,40 @@
+from enum import Enum
+
+from ...signal.signal import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+from ..utils import FileWriteMode
+from .nd_plugin import NDPluginBase
+
+
+class Compression(str, Enum):
+    none = "None"
+    nbit = "N-bit"
+    szip = "szip"
+    zlib = "zlib"
+    blosc = "Blosc"
+    bslz4 = "BSLZ4"
+    lz4 = "LZ4"
+    jpeg = "JPEG"
+
+
+class NDFileHDF(NDPluginBase):
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some signals
+        self.position_mode = epics_signal_rw_rbv(bool, prefix + "PositionMode")
+        self.compression = epics_signal_rw_rbv(Compression, prefix + "Compression")
+        self.num_extra_dims = epics_signal_rw_rbv(int, prefix + "NumExtraDims")
+        self.file_path = epics_signal_rw_rbv(str, prefix + "FilePath")
+        self.file_name = epics_signal_rw_rbv(str, prefix + "FileName")
+        self.file_path_exists = epics_signal_r(bool, prefix + "FilePathExists_RBV")
+        self.file_template = epics_signal_rw_rbv(str, prefix + "FileTemplate")
+        self.full_file_name = epics_signal_r(str, prefix + "FullFileName_RBV")
+        self.file_write_mode = epics_signal_rw_rbv(
+            FileWriteMode, prefix + "FileWriteMode"
+        )
+        self.num_capture = epics_signal_rw_rbv(int, prefix + "NumCapture")
+        self.num_captured = epics_signal_r(int, prefix + "NumCaptured_RBV")
+        self.swmr_mode = epics_signal_rw_rbv(bool, prefix + "SWMRMode")
+        self.lazy_open = epics_signal_rw_rbv(bool, prefix + "LazyOpen")
+        self.capture = epics_signal_rw_rbv(bool, prefix + "Capture")
+        self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
+        self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
+        super().__init__(prefix, name)

ophyd_async/epics/areadetector/writers/nd_plugin.py

@@ -0,0 +1,38 @@
+from enum import Enum
+
+from ophyd_async.core import Device
+from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw_rbv
+
+
+class Callback(str, Enum):
+    Enable = "Enable"
+    Disable = "Disable"
+
+
+class NDArrayBase(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
+        self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
+        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
+        self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
+        self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
+        self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
+        # There is no _RBV for this one
+        self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")
+
+        super().__init__(name=name)
+
+
+class NDPluginBase(NDArrayBase):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
+        self.enable_callback = epics_signal_rw_rbv(Callback, prefix + "EnableCallbacks")
+        self.nd_array_address = epics_signal_rw_rbv(int, prefix + "NDArrayAddress")
+        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0_RBV")
+        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1_RBV")
+        super().__init__(prefix, name)
+
+
+class NDPluginStats(NDPluginBase):
+    pass

ophyd_async/epics/demo/__init__.py

@@ -6,20 +6,33 @@ import random
 import string
 import subprocess
 import sys
-import time
 from enum import Enum
 from pathlib import Path
-from typing import Callable, List, Optional
 
 import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, Device, StandardReadable, observe_value
+from ophyd_async.core import (
+    ConfigSignal,
+    Device,
+    DeviceVector,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    observe_value,
+)
+from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core.utils import (
+    DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    CalculateTimeout,
+    WatcherUpdate,
+)
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
 
-class EnergyMode(Enum):
+class EnergyMode(str, Enum):
     """Energy mode for `Sensor`"""
 
     #: Low energy mode
@@ -33,35 +46,41 @@ class Sensor(StandardReadable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        self.value = epics_signal_r(float, prefix + "Value")
-        self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.value],
-            config=[self.mode],
-        )
+        with self.add_children_as_readables(HintedSignal):
+            self.value = epics_signal_r(float, prefix + "Value")
+        with self.add_children_as_readables(ConfigSignal):
+            self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
+
         super().__init__(name=name)
 
 
+class SensorGroup(StandardReadable):
+    def __init__(self, prefix: str, name: str = "", sensor_count: int = 3) -> None:
+        with self.add_children_as_readables():
+            self.sensors = DeviceVector(
+                {i: Sensor(f"{prefix}{i}:") for i in range(1, sensor_count + 1)}
+            )
+
+        super().__init__(name)
+
+
 class Mover(StandardReadable, Movable, Stoppable):
     """A demo movable that moves based on velocity"""
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
+        with self.add_children_as_readables(HintedSignal):
+            self.readback = epics_signal_r(float, prefix + "Readback")
+        with self.add_children_as_readables(ConfigSignal):
+            self.velocity = epics_signal_rw(float, prefix + "Velocity")
+            self.units = epics_signal_r(str, prefix + "Readback.EGU")
         self.setpoint = epics_signal_rw(float, prefix + "Setpoint")
-        self.readback = epics_signal_r(float, prefix + "Readback")
-        self.velocity = epics_signal_rw(float, prefix + "Velocity")
-        self.units = epics_signal_r(str, prefix + "Readback.EGU")
         self.precision = epics_signal_r(int, prefix + "Readback.PREC")
         # Signals that collide with standard methods should have a trailing underscore
         self.stop_ = epics_signal_x(prefix + "Stop.PROC")
         # Whether set() should complete successfully or not
         self._set_success = True
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.readback],
-            config=[self.velocity, self.units],
-        )
+
         super().__init__(name=name)
 
     def set_name(self, name: str):
@@ -69,50 +88,47 @@ class Mover(StandardReadable, Movable, Stoppable):
         # Readback should be named the same as its parent in read()
         self.readback.set_name(name)
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
+    @WatchableAsyncStatus.wrap
+    async def set(
+        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
+    ):
         self._set_success = True
-        # time.monotonic won't go backwards in case of NTP corrections
-        start = time.monotonic()
-        old_position, units, precision = await asyncio.gather(
+        old_position, units, precision, velocity = await asyncio.gather(
             self.setpoint.get_value(),
             self.units.get_value(),
             self.precision.get_value(),
+            self.velocity.get_value(),
         )
+        if timeout is CalculateTimeout:
+            assert velocity > 0, "Mover has zero velocity"
+            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
+        # Make an Event that will be set on completion, and a Status that will
+        # error if not done in time
+        done = asyncio.Event()
+        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))
         # Wait for the value to set, but don't wait for put completion callback
         await self.setpoint.set(new_position, wait=False)
-        async for current_position in observe_value(self.readback):
-            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,
-                )
+        async for current_position in observe_value(
+            self.readback, done_status=done_status
+        ):
+            yield WatcherUpdate(
+                current=current_position,
+                initial=old_position,
+                target=new_position,
+                name=self.name,
+                unit=units,
+                precision=precision,
+            )
             if np.isclose(current_position, new_position):
+                done.set()
                 break
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
 
-    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
-
-    # TODO: this fails if we call from the cli, but works if we "ipython await" it
-    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)
-
     async def stop(self, success=True):
         self._set_success = success
-        await self.stop_.execute()
+        status = self.stop_.trigger()
+        await status
 
 
 class SampleStage(Device):
@@ -134,11 +150,22 @@ def start_ioc_subprocess() -> str:
     pv_prefix = "".join(random.choice(string.ascii_uppercase) for _ in range(12)) + ":"
     here = Path(__file__).absolute().parent
     args = [sys.executable, "-m", "epicscorelibs.ioc"]
+
+    # Create standalone sensor
     args += ["-m", f"P={pv_prefix}"]
     args += ["-d", str(here / "sensor.db")]
-    for suff in "XY":
-        args += ["-m", f"P={pv_prefix}{suff}:"]
+
+    # Create sensor group
+    for suffix in ["1", "2", "3"]:
+        args += ["-m", f"P={pv_prefix}{suffix}:"]
+        args += ["-d", str(here / "sensor.db")]
+
+    # Create X and Y motors
+    for suffix in ["X", "Y"]:
+        args += ["-m", f"P={pv_prefix}{suffix}:"]
         args += ["-d", str(here / "mover.db")]
+
+    # Start IOC
     process = subprocess.Popen(
         args,
         stdin=subprocess.PIPE,

ophyd_async/epics/demo/demo_ad_sim_detector.py

@@ -0,0 +1,35 @@
+from typing import Sequence
+
+from ophyd_async.core import DirectoryProvider, SignalR, StandardDetector
+
+from ..areadetector.controllers import ADSimController
+from ..areadetector.drivers import ADBase, ADBaseShapeProvider
+from ..areadetector.writers import HDFWriter, NDFileHDF
+
+
+class DemoADSimDetector(StandardDetector):
+    _controller: ADSimController
+    _writer: HDFWriter
+
+    def __init__(
+        self,
+        drv: ADBase,
+        hdf: NDFileHDF,
+        directory_provider: DirectoryProvider,
+        name: str = "",
+        config_sigs: Sequence[SignalR] = (),
+    ):
+        self.drv = drv
+        self.hdf = hdf
+
+        super().__init__(
+            ADSimController(self.drv),
+            HDFWriter(
+                self.hdf,
+                directory_provider,
+                lambda: self.name,
+                ADBaseShapeProvider(self.drv),
+            ),
+            config_sigs=config_sigs,
+            name=name,
+        )

ophyd_async/epics/motion/motor.py

@@ -1,10 +1,20 @@
 import asyncio
-import time
-from typing import Callable, List, Optional
 
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core import (
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+)
+from ophyd_async.core.signal import observe_value
+from ophyd_async.core.utils import (
+    DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    CalculateTimeout,
+    WatcherUpdate,
+)
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -14,71 +24,76 @@ class Motor(StandardReadable, Movable, Stoppable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        self.setpoint = epics_signal_rw(float, prefix + ".VAL")
-        self.readback = epics_signal_r(float, prefix + ".RBV")
-        self.velocity = epics_signal_rw(float, prefix + ".VELO")
-        self.units = epics_signal_r(str, prefix + ".EGU")
+        with self.add_children_as_readables(ConfigSignal):
+            self.motor_egu = epics_signal_r(str, prefix + ".EGU")
+            self.velocity = epics_signal_rw(float, prefix + ".VELO")
+
+        with self.add_children_as_readables(HintedSignal):
+            self.user_readback = epics_signal_r(float, prefix + ".RBV")
+
+        self.user_setpoint = epics_signal_rw(float, prefix + ".VAL")
+        self.max_velocity = epics_signal_r(float, prefix + ".VMAX")
+        self.acceleration_time = epics_signal_rw(float, prefix + ".ACCL")
         self.precision = epics_signal_r(int, prefix + ".PREC")
-        # Signals that collide with standard methods should have a trailing underscore
-        self.stop_ = epics_signal_x(prefix + ".STOP")
+        self.deadband = epics_signal_r(float, prefix + ".RDBD")
+        self.motor_done_move = epics_signal_r(int, prefix + ".DMOV")
+        self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
+        self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
+
+        self.motor_stop = epics_signal_x(prefix + ".STOP")
         # Whether set() should complete successfully or not
         self._set_success = True
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.readback],
-            config=[self.velocity, self.units],
-        )
         super().__init__(name=name)
 
     def set_name(self, name: str):
         super().set_name(name)
         # Readback should be named the same as its parent in read()
-        self.readback.set_name(name)
+        self.user_readback.set_name(name)
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
+    @WatchableAsyncStatus.wrap
+    async def set(
+        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
+    ):
         self._set_success = True
-        start = time.monotonic()
-        old_position, units, precision = await asyncio.gather(
-            self.setpoint.get_value(),
-            self.units.get_value(),
+        (
+            old_position,
+            units,
+            precision,
+            velocity,
+            acceleration_time,
+        ) = await asyncio.gather(
+            self.user_setpoint.get_value(),
+            self.motor_egu.get_value(),
             self.precision.get_value(),
+            self.velocity.get_value(),
+            self.acceleration_time.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.readback.subscribe_value(update_watchers)
-        try:
-            await self.setpoint.set(new_position)
-        finally:
-            self.readback.clear_sub(update_watchers)
+        if timeout is CalculateTimeout:
+            assert velocity > 0, "Motor has zero velocity"
+            timeout = (
+                abs(new_position - old_position) / velocity
+                + 2 * acceleration_time
+                + DEFAULT_TIMEOUT
+            )
+        move_status = self.user_setpoint.set(new_position, wait=True, timeout=timeout)
+        async for current_position in observe_value(
+            self.user_readback, done_status=move_status
+        ):
+            yield WatcherUpdate(
+                current=current_position,
+                initial=old_position,
+                target=new_position,
+                name=self.name,
+                unit=units,
+                precision=precision,
+            )
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
 
-    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)
-
     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
-        await self.stop_.execute(wait=False)
+        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/__init__.py

@@ -0,0 +1,3 @@
+from .pvi import PVIEntry, create_children_from_annotations, fill_pvi_entries
+
+__all__ = ["PVIEntry", "fill_pvi_entries", "create_children_from_annotations"]