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

ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3a5'
+__version__ = version = '0.3a6'
 __version_tuple__ = version_tuple = (0, 3)

ophyd_async/core/__init__.py

@@ -57,6 +57,8 @@ from .soft_signal_backend import SoftSignalBackend
 from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
 from .utils import (
     DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    CalculateTimeout,
     Callback,
     NotConnected,
     ReadingValueCallback,
@@ -108,6 +110,8 @@ __all__ = [
     "TriggerInfo",
     "TriggerLogic",
     "HardwareTriggeredFlyable",
+    "CalculateTimeout",
+    "CalculatableTimeout",
     "DEFAULT_TIMEOUT",
     "Callback",
     "NotConnected",

ophyd_async/core/async_status.py

@@ -9,7 +9,6 @@ from typing import (
     Awaitable,
     Callable,
     Generic,
-    SupportsFloat,
     Type,
     TypeVar,
     cast,
@@ -27,15 +26,11 @@ WAS = TypeVar("WAS", bound="WatchableAsyncStatus")
 class AsyncStatusBase(Status):
     """Convert asyncio awaitable to bluesky Status interface"""
 
-    def __init__(self, awaitable: Awaitable, timeout: SupportsFloat | None = None):
-        if isinstance(timeout, SupportsFloat):
-            timeout = float(timeout)
+    def __init__(self, awaitable: Awaitable):
         if isinstance(awaitable, asyncio.Task):
             self.task = awaitable
         else:
-            self.task = asyncio.create_task(
-                asyncio.wait_for(awaitable, timeout=timeout)
-            )
+            self.task = asyncio.create_task(awaitable)
         self.task.add_done_callback(self._run_callbacks)
         self._callbacks: list[Callback[Status]] = []
 
@@ -49,9 +44,8 @@ class AsyncStatusBase(Status):
             self._callbacks.append(callback)
 
     def _run_callbacks(self, task: asyncio.Task):
-        if not task.cancelled():
-            for callback in self._callbacks:
-                callback(self)
+        for callback in self._callbacks:
+            callback(self)
 
     def exception(self, timeout: float | None = 0.0) -> BaseException | None:
         if timeout != 0.0:
@@ -93,14 +87,11 @@ class AsyncStatusBase(Status):
 class AsyncStatus(AsyncStatusBase):
     @classmethod
     def wrap(cls: Type[AS], f: Callable[P, Awaitable]) -> Callable[P, AS]:
+        """Wrap an async function in an AsyncStatus."""
+
         @functools.wraps(f)
         def wrap_f(*args: P.args, **kwargs: P.kwargs) -> AS:
-            # We can't type this more properly because Concatenate/ParamSpec doesn't
-            # yet support keywords
-            # https://peps.python.org/pep-0612/#concatenating-keyword-parameters
-            timeout = kwargs.get("timeout")
-            assert isinstance(timeout, SupportsFloat) or timeout is None
-            return cls(f(*args, **kwargs), timeout=timeout)
+            return cls(f(*args, **kwargs))
 
         # type is actually functools._Wrapped[P, Awaitable, P, AS]
         # but functools._Wrapped is not necessarily available
@@ -110,15 +101,11 @@ class AsyncStatus(AsyncStatusBase):
 class WatchableAsyncStatus(AsyncStatusBase, Generic[T]):
     """Convert AsyncIterator of WatcherUpdates to bluesky Status interface."""
 
-    def __init__(
-        self,
-        iterator: AsyncIterator[WatcherUpdate[T]],
-        timeout: SupportsFloat | None = None,
-    ):
+    def __init__(self, iterator: AsyncIterator[WatcherUpdate[T]]):
         self._watchers: list[Watcher] = []
         self._start = time.monotonic()
         self._last_update: WatcherUpdate[T] | None = None
-        super().__init__(self._notify_watchers_from(iterator), timeout)
+        super().__init__(self._notify_watchers_from(iterator))
 
     async def _notify_watchers_from(self, iterator: AsyncIterator[WatcherUpdate[T]]):
         async for update in iterator:
@@ -146,14 +133,10 @@ class WatchableAsyncStatus(AsyncStatusBase, Generic[T]):
         cls: Type[WAS],
         f: Callable[P, AsyncIterator[WatcherUpdate[T]]],
     ) -> Callable[P, WAS]:
-        """Wrap an AsyncIterator in a WatchableAsyncStatus. If it takes
-        'timeout' as an argument, this must be a float or None, and it
-        will be propagated to the status."""
+        """Wrap an AsyncIterator in a WatchableAsyncStatus."""
 
         @functools.wraps(f)
         def wrap_f(*args: P.args, **kwargs: P.kwargs) -> WAS:
-            timeout = kwargs.get("timeout")
-            assert isinstance(timeout, SupportsFloat) or timeout is None
-            return cls(f(*args, **kwargs), timeout=timeout)
+            return cls(f(*args, **kwargs))
 
         return cast(Callable[P, WAS], wrap_f)

ophyd_async/core/detector.py

@@ -332,7 +332,7 @@ class StandardDetector(
         # Collect stream datum documents for all indices written.
         # The index is optional, and provided for fly scans, however this needs to be
         # retrieved for step scans.
-        if not index:
+        if index is None:
             index = await self.writer.get_indices_written()
         async for doc in self.writer.collect_stream_docs(index):
             yield doc

ophyd_async/core/device.py

@@ -1,7 +1,5 @@
 """Base device"""
 
-from __future__ import annotations
-
 import asyncio
 import sys
 from functools import cached_property
@@ -32,7 +30,7 @@ class Device(HasName):
 
     _name: str = ""
     #: The parent Device if it exists
-    parent: Optional[Device] = None
+    parent: Optional["Device"] = None
     # None if connect hasn't started, a Task if it has
     _connect_task: Optional[asyncio.Task] = None
     _connect_mock_arg: bool = False
@@ -51,7 +49,7 @@ class Device(HasName):
             getLogger("ophyd_async.devices"), {"ophyd_async_device_name": self.name}
         )
 
-    def children(self) -> Iterator[Tuple[str, Device]]:
+    def children(self) -> Iterator[Tuple[str, "Device"]]:
         for attr_name, attr in self.__dict__.items():
             if attr_name != "parent" and isinstance(attr, Device):
                 yield attr_name, attr

ophyd_async/core/flyer.py

@@ -39,7 +39,7 @@ class HardwareTriggeredFlyable(
     def __init__(
         self,
         trigger_logic: TriggerLogic[T],
-        configuration_signals: Sequence[SignalR],
+        configuration_signals: Sequence[SignalR] = (),
         name: str = "",
     ):
         self._trigger_logic = trigger_logic

ophyd_async/core/mock_signal_utils.py

@@ -1,5 +1,5 @@
 from contextlib import asynccontextmanager, contextmanager
-from typing import Any, Callable, Generator, Iterable, Iterator, List
+from typing import Any, Callable, Iterable, Iterator, List
 from unittest.mock import ANY, Mock
 
 from ophyd_async.core.signal import Signal
@@ -127,11 +127,7 @@ def _unset_side_effect_cm(put_mock: Mock):
     put_mock.side_effect = None
 
 
-# linting isn't smart enought to realize @contextmanager will give use a
-# ContextManager[None]
-def callback_on_mock_put(
-    signal: Signal, callback: Callable[[T], None]
-) -> Generator[None, None, None]:
+def callback_on_mock_put(signal: Signal, callback: Callable[[T], None]):
     """For setting a callback when a backend is put to.
 
     Can either be used in a context, with the callback being

ophyd_async/core/signal.py

@@ -32,7 +32,7 @@ from .async_status import AsyncStatus
 from .device import Device
 from .signal_backend import SignalBackend
 from .soft_signal_backend import SoftSignalBackend
-from .utils import DEFAULT_TIMEOUT, Callback, T
+from .utils import DEFAULT_TIMEOUT, CalculatableTimeout, CalculateTimeout, Callback, T
 
 
 def _add_timeout(func):
@@ -213,15 +213,14 @@ class SignalR(Signal[T], AsyncReadable, AsyncStageable, Subscribable):
         self._del_cache(self._get_cache().set_staged(False))
 
 
-USE_DEFAULT_TIMEOUT = "USE_DEFAULT_TIMEOUT"
-
-
 class SignalW(Signal[T], Movable):
     """Signal that can be set"""
 
-    def set(self, value: T, wait=True, timeout=USE_DEFAULT_TIMEOUT) -> AsyncStatus:
+    def set(
+        self, value: T, wait=True, timeout: CalculatableTimeout = CalculateTimeout
+    ) -> AsyncStatus:
         """Set the value and return a status saying when it's done"""
-        if timeout is USE_DEFAULT_TIMEOUT:
+        if timeout is CalculateTimeout:
             timeout = self._timeout
 
         async def do_set():
@@ -248,9 +247,11 @@ class SignalRW(SignalR[T], SignalW[T], Locatable):
 class SignalX(Signal):
     """Signal that puts the default value"""
 
-    def trigger(self, wait=True, timeout=USE_DEFAULT_TIMEOUT) -> AsyncStatus:
+    def trigger(
+        self, wait=True, timeout: CalculatableTimeout = CalculateTimeout
+    ) -> AsyncStatus:
         """Trigger the action and return a status saying when it's done"""
-        if timeout is USE_DEFAULT_TIMEOUT:
+        if timeout is CalculateTimeout:
             timeout = self._timeout
         coro = self._backend.put(None, wait=wait, timeout=timeout)
         return AsyncStatus(coro)
@@ -270,7 +271,7 @@ def soft_signal_r_and_setter(
     datatype: Optional[Type[T]] = None,
     initial_value: Optional[T] = None,
     name: str = "",
-) -> Tuple[SignalR[T], Callable[[T]]]:
+) -> Tuple[SignalR[T], Callable[[T], None]]:
     """Returns a tuple of a read-only Signal and a callable through
     which the signal can be internally modified within the device. Use
     soft_signal_rw if you want a device that is externally modifiable
@@ -394,7 +395,7 @@ def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
 
 
 async def observe_value(
-    signal: SignalR[T], timeout=None, done_status: Status | None = None
+    signal: SignalR[T], timeout: float | None = None, done_status: Status | None = None
 ) -> AsyncGenerator[T, None]:
     """Subscribe to the value of a signal so it can be iterated from.
 
@@ -403,8 +404,12 @@ async def observe_value(
     signal:
         Call subscribe_value on this at the start, and clear_sub on it at the
         end
+    timeout:
+        If given, how long to wait for each updated value in seconds. If an update
+        is not produced in this time then raise asyncio.TimeoutError
     done_status:
         If this status is complete, stop observing and make the iterator return.
+        If it raises an exception then this exception will be raised by the iterator.
 
     Notes
     -----
@@ -414,9 +419,7 @@ async def observe_value(
             do_something_with(value)
     """
 
-    class StatusIsDone: ...
-
-    q: asyncio.Queue[T | StatusIsDone] = asyncio.Queue()
+    q: asyncio.Queue[T | Status] = asyncio.Queue()
     if timeout is None:
         get_value = q.get
     else:
@@ -425,16 +428,19 @@ async def observe_value(
             return await asyncio.wait_for(q.get(), timeout)
 
     if done_status is not None:
-        done_status.add_callback(lambda _: q.put_nowait(StatusIsDone()))
+        done_status.add_callback(q.put_nowait)
 
     signal.subscribe_value(q.put_nowait)
     try:
         while True:
             item = await get_value()
-            if not isinstance(item, StatusIsDone):
-                yield item
+            if done_status and item is done_status:
+                if exc := done_status.exception():
+                    raise exc
+                else:
+                    break
             else:
-                break
+                yield item
     finally:
         signal.clear_sub(q.put_nowait)
 

ophyd_async/core/utils.py

@@ -31,6 +31,17 @@ DEFAULT_TIMEOUT = 10.0
 ErrorText = Union[str, Dict[str, Exception]]
 
 
+class CalculateTimeout:
+    """Sentinel class used to implement ``myfunc(timeout=CalculateTimeout)``
+
+    This signifies that the function should calculate a suitable non-zero
+    timeout itself
+    """
+
+
+CalculatableTimeout = float | None | Type[CalculateTimeout]
+
+
 class NotConnected(Exception):
     """Exception to be raised if a `Device.connect` is cancelled"""
 

ophyd_async/epics/areadetector/drivers/ad_base.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     set_and_wait_for_value,
 )
 
-from ...signal.signal import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+from ...signal.signal import epics_signal_r, epics_signal_rw_rbv
 from ..utils import ImageMode
 from ..writers.nd_plugin import NDArrayBase
 
@@ -43,18 +43,12 @@ DEFAULT_GOOD_STATES: FrozenSet[DetectorState] = frozenset(
 class ADBase(NDArrayBase):
     def __init__(self, prefix: str, name: str = "") -> None:
         # Define some signals
-        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
         self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
         self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
         self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
-        self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
-        self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
-        self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
         self.detector_state = epics_signal_r(
             DetectorState, prefix + "DetectorState_RBV"
         )
-        # There is no _RBV for this one
-        self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")
         super().__init__(prefix, name=name)
 
 

ophyd_async/epics/areadetector/writers/hdf_writer.py

@@ -43,12 +43,13 @@ class HDFWriter(DetectorWriter):
     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(str(info.root / info.resource_dir)),
+            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),
@@ -59,7 +60,7 @@ class HDFWriter(DetectorWriter):
 
         assert (
             await self.hdf.file_path_exists.get_value()
-        ), f"File path {self.hdf.file_path.get_value()} for hdf plugin does not exist"
+        ), f"File path {file_path} for hdf plugin does not exist"
 
         # Overwrite num_capture to go forever
         await self.hdf.num_capture.set(0)

ophyd_async/epics/areadetector/writers/nd_file_hdf.py

@@ -36,7 +36,5 @@ class NDFileHDF(NDPluginBase):
         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.array_size0 = epics_signal_r(int, prefix + "ArraySize0_RBV")
-        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1_RBV")
         self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/writers/nd_plugin.py

@@ -14,6 +14,13 @@ 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)
 
 
@@ -22,6 +29,8 @@ class NDPluginBase(NDArrayBase):
         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)
 
 

ophyd_async/epics/demo/__init__.py

@@ -6,7 +6,6 @@ import random
 import string
 import subprocess
 import sys
-from dataclasses import replace
 from enum import Enum
 from pathlib import Path
 
@@ -22,7 +21,13 @@ from ophyd_async.core import (
     WatchableAsyncStatus,
     observe_value,
 )
-from ophyd_async.core.utils import WatcherUpdate
+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
 
@@ -66,11 +71,9 @@ class Mover(StandardReadable, Movable, Stoppable):
         # 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.precision = epics_signal_r(int, prefix + "Readback.PREC")
         # Signals that collide with standard methods should have a trailing underscore
@@ -85,41 +88,42 @@ 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):
+    @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
-        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
-        move_status = self.setpoint.set(new_position, wait=True)
-        if not self._set_success:
-            raise RuntimeError("Motor was stopped")
-        # return a template to set() which it can use to yield progress updates
-        return (
-            WatcherUpdate(
+        await self.setpoint.set(new_position, wait=False)
+        async for current_position in observe_value(
+            self.readback, done_status=done_status
+        ):
+            yield WatcherUpdate(
+                current=current_position,
                 initial=old_position,
-                current=old_position,
                 target=new_position,
+                name=self.name,
                 unit=units,
                 precision=precision,
-            ),
-            move_status,
-        )
-
-    @WatchableAsyncStatus.wrap  # uses the timeout argument from the function it wraps
-    async def set(self, new_position: float, timeout: float | None = None):
-        update, _ = await self._move(new_position)
-        async for current_position in observe_value(self.readback):
-            yield replace(
-                update,
-                name=self.name,
-                current=current_position,
             )
             if np.isclose(current_position, new_position):
+                done.set()
                 break
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
 
     async def stop(self, success=True):
         self._set_success = success

ophyd_async/epics/motion/motor.py

@@ -1,17 +1,20 @@
 import asyncio
-from dataclasses import replace
 
 from bluesky.protocols import Movable, Stoppable
 
 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 ophyd_async.core.utils import (
+    DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    CalculateTimeout,
+    WatcherUpdate,
+)
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -47,42 +50,45 @@ 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
-    ) -> tuple[WatcherUpdate[float], AsyncStatus]:
+    @WatchableAsyncStatus.wrap
+    async def set(
+        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
+    ):
         self._set_success = True
-        old_position, units, precision = await asyncio.gather(
+        (
+            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(),
         )
-        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,
-        )
-
-    @WatchableAsyncStatus.wrap
-    async def set(self, new_position: float, timeout: float | None = None):
-        update, move_status = await self._move(new_position)
+        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
         ):
-            if not self._set_success:
-                raise RuntimeError("Motor was stopped")
-            yield replace(
-                update,
-                name=self.name,
+            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")
 
     async def stop(self, success=False):
         self._set_success = success

ophyd_async/panda/__init__.py

@@ -15,6 +15,7 @@ from ._table import (
     seq_table_from_arrays,
     seq_table_from_rows,
 )
+from ._trigger import StaticSeqTableTriggerLogic
 from ._utils import phase_sorter
 
 __all__ = [
@@ -33,4 +34,5 @@ __all__ = [
     "TimeUnits",
     "DataBlock",
     "CommonPandABlocks",
+    "StaticSeqTableTriggerLogic",
 ]

ophyd_async/panda/writers/_hdf_writer.py

@@ -79,10 +79,10 @@ async def get_signals_marked_for_capture(
         capture_signals.keys(), capture_signals.values(), signal_values
     ):
         signal_path = signal_path.replace("_capture", "")
-        if (signal_value.value in iter(Capture)) and (signal_value.value != Capture.No):
+        if (signal_value in iter(Capture)) and (signal_value != Capture.No):
             signals_to_capture[signal_path] = CaptureSignalWrapper(
                 signal_object,
-                signal_value.value,
+                signal_value,
             )
 
     return signals_to_capture
@@ -126,7 +126,7 @@ class PandaHDFWriter(DetectorWriter):
                 str(info.root / info.resource_dir)
             ),
             self.panda_device.data.hdf_file_name.set(
-                f"{info.prefix}{self.panda_device.name}{info.suffix}",
+                f"{info.prefix}{self.panda_device.name}{info.suffix}.h5",
             ),
             self.panda_device.data.num_capture.set(0),
         )
@@ -149,7 +149,7 @@ class PandaHDFWriter(DetectorWriter):
                 else split_path[-2]
             )
 
-            for suffix in str(capture_signal.capture_type).split(" "):
+            for suffix in capture_signal.capture_type.split(" "):
                 self._datasets.append(
                     _HDFDataset(
                         name,

ophyd_async/{planstubs → plan_stubs}/__init__.py

@@ -1,9 +1,13 @@
 from .ensure_connected import ensure_connected
-from .prepare_trigger_and_dets import (
+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,
 )
 
 __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",
 ]

ophyd_async/plan_stubs/fly.py

@@ -0,0 +1,149 @@
+from typing import List
+
+import bluesky.plan_stubs as bps
+from bluesky.utils import short_uid
+
+from ophyd_async.core.detector import DetectorTrigger, StandardDetector, TriggerInfo
+from ophyd_async.core.flyer import HardwareTriggeredFlyable
+from ophyd_async.core.utils import in_micros
+from ophyd_async.panda._table import SeqTable, SeqTableRow, seq_table_from_rows
+from ophyd_async.panda._trigger import SeqTableInfo
+
+
+def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
+    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    detectors: List[StandardDetector],
+    number_of_frames: int,
+    exposure: float,
+    shutter_time: float,
+    repeats: int = 1,
+    period: float = 0.0,
+):
+    """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)
+
+    trigger_info = TriggerInfo(
+        num=number_of_frames * repeats,
+        trigger=DetectorTrigger.constant_gate,
+        deadtime=deadtime,
+        livetime=exposure,
+    )
+    trigger_time = number_of_frames * (exposure + deadtime)
+    pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
+
+    table: SeqTable = seq_table_from_rows(
+        # Wait for pre-delay then open shutter
+        SeqTableRow(
+            time1=in_micros(pre_delay),
+            time2=in_micros(shutter_time),
+            outa2=True,
+        ),
+        # Keeping shutter open, do N triggers
+        SeqTableRow(
+            repeats=number_of_frames,
+            time1=in_micros(exposure),
+            outa1=True,
+            outb1=True,
+            time2=in_micros(deadtime),
+            outa2=True,
+        ),
+        # Add the shutter close
+        SeqTableRow(time2=in_micros(shutter_time)),
+    )
+
+    table_info = SeqTableInfo(table, 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: HardwareTriggeredFlyable[SeqTableInfo],
+    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 time_resolved_fly_and_collect_with_static_seq_table(
+    stream_name: str,
+    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    detectors: List[StandardDetector],
+    number_of_frames: int,
+    exposure: float,
+    shutter_time: float,
+    repeats: int = 1,
+    period: float = 0.0,
+):
+    """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,
+    )
+    # Run the fly scan
+    yield from fly_and_collect(stream_name, flyer, detectors)

ophyd_async/sim/demo/sim_motor.py

@@ -1,6 +1,6 @@
 import asyncio
+import contextlib
 import time
-from dataclasses import replace
 
 from bluesky.protocols import Movable, Stoppable
 
@@ -25,109 +25,79 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         - name: str: name of device
         - instant: bool: whether to move instantly, or with a delay
         """
+        # Define some signals
         with self.add_children_as_readables(HintedSignal):
             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(str, "mm")
-
-        self._instant = instant
-        self._move_status: AsyncStatus | None = None
-
-        # Define some signals
+            self.velocity = soft_signal_rw(float, 0 if instant else 1.0)
+            self.units = soft_signal_rw(str, "mm")
         self.user_setpoint = soft_signal_rw(float, 0)
 
-        super().__init__(name=name)
-
         # Whether set() should complete successfully or not
         self._set_success = True
+        self._move_status: AsyncStatus | None = None
 
-    def stop(self, success=False):
-        """
-        Stop the motor if it is moving
-        """
-        if self._move_status:
-            self._move_status.task.cancel()
-            self._move_status = None
+        super().__init__(name=name)
 
-        async def trigger_callbacks():
-            await self.user_readback._backend.put(
-                await self.user_readback._backend.get_value()
-            )
+    async def _move(self, old_position: float, new_position: float, move_time: float):
+        start = time.monotonic()
+        distance = abs(new_position - old_position)
+        while True:
+            time_elapsed = round(time.monotonic() - start, 2)
 
-        asyncio.create_task(trigger_callbacks())
+            # update position based on time elapsed
+            if time_elapsed >= move_time:
+                # successfully reached our target position
+                self._user_readback_set(new_position)
+                break
+            else:
+                current_position = old_position + distance * time_elapsed / move_time
 
-        self._set_success = success
+            self._user_readback_set(current_position)
+
+            # 10hz update loop
+            await asyncio.sleep(0.1)
 
     @WatchableAsyncStatus.wrap
-    async def set(self, new_position: float, timeout: float | None = None):
+    async def set(self, new_position: float):
         """
         Asynchronously move the motor to a new position.
         """
-        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, timeout: float | None = None):
-        """
-        Start the motor moving to a new position.
-
-        If the motor is already moving, it will stop first.
-        If this is an instant motor the move will be instantaneous.
-        """
-        self.stop()
-        start = time.monotonic()
-        self._set_success = True
-
-        current_position = await self.user_readback.get_value()
-        distance = abs(new_position - current_position)
-        travel_time = 0 if self._instant else distance / await self.velocity.get_value()
-
-        old_position, units = await asyncio.gather(
+        # Make sure any existing move tasks are stopped
+        await self.stop()
+        old_position, units, velocity = await asyncio.gather(
             self.user_setpoint.get_value(),
-            self.egu.get_value(),
+            self.units.get_value(),
+            self.velocity.get_value(),
         )
-
-        async def update_position():
-            while True:
-                time_elapsed = round(time.monotonic() - start, 2)
-
-                # update position based on time elapsed
-                if time_elapsed >= travel_time:
-                    # successfully reached our target position
-                    self._user_readback_set(new_position)
-                    self._set_success = True
-                    break
-                else:
-                    current_position = (
-                        old_position + distance * time_elapsed / travel_time
-                    )
-
-                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_status = AsyncStatus(asyncio.wait_for(update_position(), timeout))
-
-        return (
-            WatcherUpdate(
-                initial=old_position,
-                current=old_position,
-                target=new_position,
-                unit=units,
-            ),
-            self._move_status,
+        # If zero velocity, do instant move
+        move_time = abs(new_position - old_position) / velocity if velocity else 0
+        self._move_status = AsyncStatus(
+            self._move(old_position, new_position, move_time)
         )
+        # If stop is called then this will raise a CancelledError, ignore it
+        with contextlib.suppress(asyncio.CancelledError):
+            async for current_position in observe_value(
+                self.user_readback, done_status=self._move_status
+            ):
+                yield WatcherUpdate(
+                    current=current_position,
+                    initial=old_position,
+                    target=new_position,
+                    name=self.name,
+                    unit=units,
+                )
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
+
+    async def stop(self, success=True):
+        """
+        Stop the motor if it is moving
+        """
+        self._set_success = success
+        if self._move_status:
+            self._move_status.task.cancel()
+            self._move_status = None
+        await self.user_setpoint.set(await self.user_readback.get_value())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a5
+Version: 0.3a6
 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

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

@@ -1,22 +1,22 @@
 ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
 ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
-ophyd_async/_version.py,sha256=U12czQTgzf6ojb0_kN2Mdxwd3eohytfYDRR6gcj6mEw,408
+ophyd_async/_version.py,sha256=LuF-BqHYcrns31aIHwEtbxWREi37LwJcIxVOaUpUzgM,408
 ophyd_async/log.py,sha256=DbMjt0bkfUOLHIinZYt0Q0FHZmCXXi5x8y0uFiEmqoQ,3587
 ophyd_async/protocols.py,sha256=EF2W9nfElV-0QNMYrX1zusL1PqDJR3kNsjlalR29j0I,3412
-ophyd_async/core/__init__.py,sha256=YMFc7rJhfq6waLMmHTCD6BVqUM_jM7joPGEoxUued7g,2893
+ophyd_async/core/__init__.py,sha256=wF90GU1BHjCzVVgBtUDHoogCIx6XNXq050wth9YPzVo,2991
 ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
-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/async_status.py,sha256=9TOgOXIAuH62RDo5t-Y5GdjrJ76d_6TFlBxYv-5_a88,4367
+ophyd_async/core/detector.py,sha256=8mdLKphirgit5CVCklJI9eHqKKiCz4CYs9BElo10-lc,11007
+ophyd_async/core/device.py,sha256=280zFnLCoiMZAA-Dh1_AjUSnhxUfKYGgj4H_2S1njOA,7086
 ophyd_async/core/device_save_loader.py,sha256=RXA3dPUPihAR2ZGDStlGiA-TAsr_xqL0snsCjMsMnfA,9138
-ophyd_async/core/flyer.py,sha256=LfO3EQTW2zMeNqZh8TLXvE92E30Duds2RXskRYAdJ_4,2299
+ophyd_async/core/flyer.py,sha256=bIjzBkrl8HVAlKgsZ_FF0WL69Qvksyzp9ZWmTLl8Yrw,2304
 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/mock_signal_utils.py,sha256=TgVV3D6i7ItXRiy98H1Ov8dKZhiop_9CdTaRjiH5cwQ,4143
+ophyd_async/core/signal.py,sha256=FbTb5qDPLhVxEbh6gimqXfkZwcqB4ymHTEYVXZVZYrk,16456
 ophyd_async/core/signal_backend.py,sha256=qDdWz8X4CWStuYknxcj4G76BLq4TzrAIyZO1NOEq9ao,1519
 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=OMOpa-5QMAGQbbb0tFD4lRnyk0Fykq4aD2EOQbPt39c,5516
+ophyd_async/core/utils.py,sha256=3oZcXNqAUHX4ZWMBH5gSuK6cFWEhSkZ9GSDYv0pf8jc,5783
 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=cpPNZmRMi7FnAh2-3ec5uklLVFOqsmEmpI1nh5Ud1Ls,8794
@@ -36,7 +36,7 @@ ophyd_async/epics/areadetector/controllers/kinetix_controller.py,sha256=9QmydX85
 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=cE7I-IsfQz3UR9yqghy4czAxHeHERTTKe080GB9sCFQ,3847
+ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=18WFAiWEUg0H2LcvTQHrKYj2wThGafQzDpiyAWki6vo,3411
 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
@@ -44,21 +44,21 @@ ophyd_async/epics/areadetector/drivers/vimba_driver.py,sha256=J54VtWkOklfbSqZYxG
 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=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/areadetector/writers/hdf_writer.py,sha256=ZpbVilNVv81OpbCrqaeZUoHLarrjzRWEGe-zI1Wxyyw,5436
+ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=EkiaEh_0U6Iz17jFi2IIsRPsVQTQIJRG8EPNCiAHkkU,1762
+ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=GUzaeTMdG07Rb1x0WzBBxMEltBhr10jb5dL29tEWXEQ,1547
+ophyd_async/epics/demo/__init__.py,sha256=ZcuZ66aIQ58WSydLOSKnk-h_W-aWjhDRZkWQA6f3sig,5790
 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=ZiyC0WvO9AAsv_FmYBaCmOYQ86yZIS3QnSxfyPUg5jE,3504
+ophyd_async/epics/motion/motor.py,sha256=G8cc-okSXJ6s2fGxRO155xm7PrBbVImBmBMRWts895k,3630
 ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
 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/__init__.py,sha256=FuSnvp-RtdA0X4RcHEF0nTiXymRts2MNdFmF_1_i41w,775
 ophyd_async/panda/_common_blocks.py,sha256=n0PPc1rar43oDSIA-yNubTc8fR5YCW1tyjQU58whsg0,1038
 ophyd_async/panda/_hdf_panda.py,sha256=QjfZyYos0ZBlIqBiZ5UbyEd_wuh_cGzwV8QE9jvLiIY,1419
 ophyd_async/panda/_panda_controller.py,sha256=dIqcjmaIHVrki8UXSoDx46kk6I2Lhpe2o3sXNg5f-RQ,1238
@@ -66,21 +66,21 @@ ophyd_async/panda/_table.py,sha256=dLoRP4zYNOkD_s0Vkp2wVYAwkjVG8nNdf8-FaXOTfPo,5
 ophyd_async/panda/_trigger.py,sha256=tBH8uq_4o1ASG9yofVxq3tjf5v8LPzniDTRL4yjramI,1195
 ophyd_async/panda/_utils.py,sha256=VHW5kPVISyEkmse_qQcyisBkkEwMO6GG2Ago-CH1AFA,487
 ophyd_async/panda/writers/__init__.py,sha256=xy7BguVQG4HNIDBfKPjMj0KQo1tptC9LbCpEuMcVGaM,70
-ophyd_async/panda/writers/_hdf_writer.py,sha256=_KlawqQHuWXLCvhGg1N6S4dQ8LhM88NbHsbXryxPvPA,7617
+ophyd_async/panda/writers/_hdf_writer.py,sha256=vnyIg3JmlzMIIq75o0IDMfGzBm_GJAhOUisAZE_0cyg,7597
 ophyd_async/panda/writers/_panda_hdf_file.py,sha256=42iHaTax4JjOBpNC7d4nkNL9SM14OTnFPTIcXv2jg-4,1759
-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/plan_stubs/__init__.py,sha256=nO9ELG9J7fYwfVTVRWVorz4kffeszYpwk1ROh6Ha--w,405
+ophyd_async/plan_stubs/ensure_connected.py,sha256=1MkDu8UqVRPHLnW9IXRn-QvKiG8-rCV8T4KDbjf9K6w,557
+ophyd_async/plan_stubs/fly.py,sha256=nl8XLoY7hvlam6H3zl4NcPRUiEJ3xIjopHEfA0ehTDg,4845
 ophyd_async/sim/__init__.py,sha256=ScjH1g7FMo5yPACfJRZE6xGBWCHU4bKDzNQk1tqObnA,366
 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=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,,
+ophyd_async/sim/demo/sim_motor.py,sha256=a2p5wnHXjF-V5zOFai7jnszk4kbGmrZRnUqBtkOgEfQ,3733
+ophyd_async-0.3a6.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.3a6.dist-info/METADATA,sha256=oFejS6nfk0zaWbJASTeSieIQnPMjC1mvkIFaUrmH1MQ,6284
+ophyd_async-0.3a6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ophyd_async-0.3a6.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.3a6.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.3a6.dist-info/RECORD,,

ophyd_async/planstubs/prepare_trigger_and_dets.py

@@ -1,57 +0,0 @@
-from typing import List
-
-import bluesky.plan_stubs as bps
-
-from ophyd_async.core.detector import DetectorTrigger, StandardDetector, TriggerInfo
-from ophyd_async.core.flyer import HardwareTriggeredFlyable
-from ophyd_async.core.utils import in_micros
-from ophyd_async.panda._table import SeqTable, SeqTableRow, seq_table_from_rows
-from ophyd_async.panda._trigger import SeqTableInfo
-
-
-def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
-    flyer: HardwareTriggeredFlyable[SeqTableInfo],
-    detectors: List[StandardDetector],
-    num: int,
-    width: float,
-    deadtime: float,
-    shutter_time: float,
-    repeats: int = 1,
-    period: float = 0.0,
-):
-    trigger_info = TriggerInfo(
-        num=num * repeats,
-        trigger=DetectorTrigger.constant_gate,
-        deadtime=deadtime,
-        livetime=width,
-    )
-
-    trigger_time = num * (width + deadtime)
-    pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
-
-    table: SeqTable = seq_table_from_rows(
-        # Wait for pre-delay then open shutter
-        SeqTableRow(
-            time1=in_micros(pre_delay),
-            time2=in_micros(shutter_time),
-            outa2=True,
-        ),
-        # Keeping shutter open, do N triggers
-        SeqTableRow(
-            repeats=num,
-            time1=in_micros(width),
-            outa1=True,
-            outb1=True,
-            time2=in_micros(deadtime),
-            outa2=True,
-        ),
-        # Add the shutter close
-        SeqTableRow(time2=in_micros(shutter_time)),
-    )
-
-    table_info = SeqTableInfo(table, 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")