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

ophyd_async/core/signal.py

@@ -21,6 +21,7 @@ from bluesky.protocols import (
     Location,
     Movable,
     Reading,
+    Status,
     Subscribable,
 )
 
@@ -31,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):
@@ -64,7 +65,9 @@ class Signal(Device, Generic[T]):
         self._initial_backend = self._backend = backend
         super().__init__(name)
 
-    async def connect(self, mock=False, timeout=DEFAULT_TIMEOUT):
+    async def connect(
+        self, mock=False, timeout=DEFAULT_TIMEOUT, force_reconnect: bool = False
+    ):
         if mock and not isinstance(self._backend, MockSignalBackend):
             # Using a soft backend, look to the initial value
             self._backend = MockSignalBackend(
@@ -210,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():
@@ -245,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)
@@ -267,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
@@ -278,6 +282,19 @@ def soft_signal_r_and_setter(
     return (signal, backend.set_value)
 
 
+def _generate_assert_error_msg(
+    name: str, expected_result: str, actuall_result: str
+) -> str:
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+    return (
+        f"Expected {WARNING}{name}{ENDC} to produce"
+        + f"\n{FAIL}{actuall_result}{ENDC}"
+        + f"\nbut actually got \n{FAIL}{expected_result}{ENDC}"
+    )
+
+
 async def assert_value(signal: SignalR[T], value: Any) -> None:
     """Assert a signal's value and compare it an expected signal.
 
@@ -294,11 +311,14 @@ async def assert_value(signal: SignalR[T], value: Any) -> None:
         await assert_value(signal, value)
 
     """
-    assert await signal.get_value() == value
+    actual_value = await signal.get_value()
+    assert actual_value == value, _generate_assert_error_msg(
+        signal.name, value, actual_value
+    )
 
 
 async def assert_reading(
-    readable: AsyncReadable, reading: Mapping[str, Reading]
+    readable: AsyncReadable, expected_reading: Mapping[str, Reading]
 ) -> None:
     """Assert readings from readable.
 
@@ -316,7 +336,10 @@ async def assert_reading(
         await assert_reading(readable, reading)
 
     """
-    assert await readable.read() == reading
+    actual_reading = await readable.read()
+    assert expected_reading == actual_reading, _generate_assert_error_msg(
+        readable.name, expected_reading, actual_reading
+    )
 
 
 async def assert_configuration(
@@ -339,7 +362,10 @@ async def assert_configuration(
         await assert_configuration(configurable configuration)
 
     """
-    assert await configurable.read_configuration() == configuration
+    actual_configurable = await configurable.read_configuration()
+    assert configuration == actual_configurable, _generate_assert_error_msg(
+        configurable.name, configuration, actual_configurable
+    )
 
 
 def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
@@ -359,11 +385,18 @@ def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
         assert_emitted(docs, start=1, descriptor=1,
         resource=1, datum=1, event=1, stop=1)
     """
-    assert list(docs) == list(numbers)
-    assert {name: len(d) for name, d in docs.items()} == numbers
-
-
-async def observe_value(signal: SignalR[T], timeout=None) -> AsyncGenerator[T, None]:
+    assert list(docs) == list(numbers), _generate_assert_error_msg(
+        "documents", list(numbers), list(docs)
+    )
+    actual_numbers = {name: len(d) for name, d in docs.items()}
+    assert actual_numbers == numbers, _generate_assert_error_msg(
+        "emitted", numbers, actual_numbers
+    )
+
+
+async def observe_value(
+    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.
 
     Parameters
@@ -371,6 +404,12 @@ async def observe_value(signal: SignalR[T], timeout=None) -> AsyncGenerator[T, N
     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
     -----
@@ -379,7 +418,8 @@ async def observe_value(signal: SignalR[T], timeout=None) -> AsyncGenerator[T, N
         async for value in observe_value(sig):
             do_something_with(value)
     """
-    q: asyncio.Queue[T] = asyncio.Queue()
+
+    q: asyncio.Queue[T | Status] = asyncio.Queue()
     if timeout is None:
         get_value = q.get
     else:
@@ -387,10 +427,20 @@ async def observe_value(signal: SignalR[T], timeout=None) -> AsyncGenerator[T, N
         async def get_value():
             return await asyncio.wait_for(q.get(), timeout)
 
+    if done_status is not None:
+        done_status.add_callback(q.put_nowait)
+
     signal.subscribe_value(q.put_nowait)
     try:
         while True:
-            yield await get_value()
+            item = await get_value()
+            if done_status and item is done_status:
+                if exc := done_status.exception():
+                    raise exc
+                else:
+                    break
+            else:
+                yield item
     finally:
         signal.clear_sub(q.put_nowait)
 

ophyd_async/core/utils.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from dataclasses import dataclass
 from typing import (
     Awaitable,
     Callable,
     Dict,
+    Generic,
     Iterable,
     List,
     Optional,
+    ParamSpec,
     Type,
     TypeVar,
     Union,
@@ -18,6 +21,7 @@ import numpy as np
 from bluesky.protocols import Reading
 
 T = TypeVar("T")
+P = ParamSpec("P")
 Callback = Callable[[T], None]
 
 #: A function that will be called with the Reading and value when the
@@ -27,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"""
 
@@ -77,6 +92,21 @@ class NotConnected(Exception):
         return self.format_error_string(indent="")
 
 
+@dataclass(frozen=True)
+class WatcherUpdate(Generic[T]):
+    """A dataclass such that, when expanded, it provides the kwargs for a watcher"""
+
+    current: T
+    initial: T
+    target: T
+    name: str | None = None
+    unit: str | None = None
+    precision: float | None = None
+    fraction: float | None = None
+    time_elapsed: float | None = None
+    time_remaining: float | None = None
+
+
 async def wait_for_connection(**coros: Awaitable[None]):
     """Call many underlying signals, accumulating exceptions and returning them
 

ophyd_async/epics/areadetector/aravis.py

@@ -2,7 +2,7 @@ from typing import get_args
 
 from bluesky.protocols import HasHints, Hints
 
-from ophyd_async.core import DirectoryProvider, StandardDetector, TriggerInfo
+from ophyd_async.core import DirectoryProvider, StandardDetector
 from ophyd_async.epics.areadetector.controllers.aravis_controller import (
     AravisController,
 )
@@ -45,10 +45,6 @@ class AravisDetector(StandardDetector, HasHints):
             name=name,
         )
 
-    async def _prepare(self, value: TriggerInfo) -> None:
-        await self.drv.fetch_deadtime()
-        await super()._prepare(value)
-
     def get_external_trigger_gpio(self):
         return self._controller.gpio_number
 

ophyd_async/epics/areadetector/controllers/aravis_controller.py

@@ -14,6 +14,11 @@ from ophyd_async.epics.areadetector.drivers.aravis_driver import (
 )
 from ophyd_async.epics.areadetector.utils import ImageMode, stop_busy_record
 
+# The deadtime of an ADaravis controller varies depending on the exact model of camera.
+# Ideally we would maximize performance by dynamically retrieving the deadtime at
+# runtime. See https://github.com/bluesky/ophyd-async/issues/308
+_HIGHEST_POSSIBLE_DEADTIME = 1961e-6
+
 
 class AravisController(DetectorControl):
     GPIO_NUMBER = Literal[1, 2, 3, 4]
@@ -23,7 +28,7 @@ class AravisController(DetectorControl):
         self.gpio_number = gpio_number
 
     def get_deadtime(self, exposure: float) -> float:
-        return self._drv.dead_time or 0
+        return _HIGHEST_POSSIBLE_DEADTIME
 
     async def arm(
         self,

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/drivers/aravis_driver.py

@@ -1,8 +1,8 @@
 from enum import Enum
-from typing import Callable, Dict, Literal, Optional, Tuple
+from typing import Literal
 
 from ophyd_async.epics.areadetector.drivers import ADBase
-from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw_rbv
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
 
 
 class AravisTriggerMode(str, Enum):
@@ -22,113 +22,6 @@ class AravisTriggerMode(str, Enum):
 AravisTriggerSource = Literal["Freerun", "Line1", "Line2", "Line3", "Line4"]
 
 
-def _reverse_lookup(
-    model_deadtimes: Dict[float, Tuple[str, ...]],
-) -> Callable[[str], float]:
-    def inner(pixel_format: str, model_name: str) -> float:
-        for deadtime, pixel_formats in model_deadtimes.items():
-            if pixel_format in pixel_formats:
-                return deadtime
-        raise ValueError(
-            f"Model {model_name} does not have a defined deadtime "
-            f"for pixel format {pixel_format}"
-        )
-
-    return inner
-
-
-_deadtimes: Dict[str, Callable[[str, str], float]] = {
-    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/Manta/techman/Manta_TechMan.pdf retrieved 2024-04-05  # noqa: E501
-    "Manta G-125": lambda _, __: 63e-6,
-    "Manta G-145": lambda _, __: 106e-6,
-    "Manta G-235": _reverse_lookup(
-        {
-            118e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            256e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            390e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-    "Manta G-895": _reverse_lookup(
-        {
-            404e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            542e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            822e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-    "Manta G-2460": _reverse_lookup(
-        {
-            979e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            1304e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            1961e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/various/appnote/GigE/GigE-Cameras_AppNote_PIV-Min-Time-Between-Exposures.pdf retrieved 2024-04-05  # noqa: E501
-    "Manta G-609": lambda _, __: 47e-6,
-    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/Mako/techman/Mako_TechMan_en.pdf retrieved 2024-04-05  # noqa: E501
-    "Mako G-040": _reverse_lookup(
-        {
-            101e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            140e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            217e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-    "Mako G-125": lambda _, __: 70e-6,
-    # Assume 12 bits: 10 bits = 275e-6
-    "Mako G-234": _reverse_lookup(
-        {
-            356e-6: (
-                "Mono8",
-                "BayerRG8",
-                "BayerRG12",
-                "BayerRG12Packed",
-                "YUV411Packed",
-                "YUV422Packed",
-            ),
-            # Assume 12 bits: 10 bits = 563e-6
-            726e-6: ("RGB8Packed", "BRG8Packed", "YUV444Packed"),
-        }
-    ),
-    "Mako G-507": _reverse_lookup(
-        {
-            270e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            363e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            554e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-}
-
-
 class AravisDriver(ADBase):
     # If instantiating a new instance, ensure it is supported in the _deadtimes dict
     """Generic Driver supporting the Manta and Mako drivers.
@@ -142,15 +35,4 @@ class AravisDriver(ADBase):
             AravisTriggerMode, prefix + "TriggerMode"
         )
         self.trigger_source = epics_signal_rw_rbv(str, prefix + "TriggerSource")
-        self.model = epics_signal_r(str, prefix + "Model_RBV")
-        self.pixel_format = epics_signal_rw_rbv(str, prefix + "PixelFormat")
-        self.dead_time: Optional[float] = None
         super().__init__(prefix, name=name)
-
-    async def fetch_deadtime(self) -> None:
-        # All known in-use version B/C have same deadtime as non-B/C
-        model: str = (await self.model.get_value()).removesuffix("B").removesuffix("C")
-        if model not in _deadtimes:
-            raise ValueError(f"Model {model} does not have defined deadtimes")
-        pixel_format: str = await self.pixel_format.get_value()
-        self.dead_time = _deadtimes.get(model)(pixel_format, model)

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,23 +6,28 @@ 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,
     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
 
@@ -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,47 +88,43 @@ 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
         status = self.stop_.trigger()