ophyd-async 0.13.7__py3-none-any.whl → 0.14.0__py3-none-any.whl

ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.7'
-__version_tuple__ = version_tuple = (0, 13, 7)
+__version__ = version = '0.14.0'
+__version_tuple__ = version_tuple = (0, 14, 0)
 
 __commit_id__ = commit_id = None

ophyd_async/core/__init__.py

@@ -14,7 +14,15 @@ from ._detector import (
     StandardDetector,
     TriggerInfo,
 )
-from ._device import Device, DeviceConnector, DeviceVector, init_devices
+from ._device import (
+    Device,
+    DeviceConnector,
+    DeviceMock,
+    DeviceVector,
+    LazyMock,
+    default_mock_class,
+    init_devices,
+)
 from ._device_filler import DeviceFiller
 from ._enums import (
     EnabledDisabled,
@@ -27,6 +35,15 @@ from ._flyer import FlyerController, FlyMotorInfo, StandardFlyer
 from ._hdf_dataset import HDFDatasetDescription, HDFDocumentComposer
 from ._log import config_ophyd_async_logging
 from ._mock_signal_backend import MockSignalBackend
+from ._mock_signal_utils import (
+    callback_on_mock_put,
+    get_mock,
+    get_mock_put,
+    mock_puts_blocked,
+    set_mock_put_proceeds,
+    set_mock_value,
+    set_mock_values,
+)
 from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable, Watcher
 from ._providers import (
     AutoIncrementFilenameProvider,
@@ -87,7 +104,6 @@ from ._utils import (
     Callback,
     ConfinedModel,
     EnumTypes,
-    LazyMock,
     NotConnectedError,
     Reference,
     StrictEnum,
@@ -166,8 +182,18 @@ __all__ = [
     "soft_signal_r_and_setter",
     "soft_signal_rw",
     # Mock signal
+    "DeviceMock",
     "LazyMock",
     "MockSignalBackend",
+    "default_mock_class",
+    # Mocking utilities
+    "get_mock",
+    "set_mock_value",
+    "set_mock_values",
+    "get_mock_put",
+    "callback_on_mock_put",
+    "mock_puts_blocked",
+    "set_mock_put_proceeds",
     # Signal utilities
     "observe_value",
     "observe_signals_value",

ophyd_async/core/_device.py

@@ -5,19 +5,71 @@ import sys
 from collections.abc import Awaitable, Callable, Iterator, Mapping, MutableMapping
 from functools import cached_property
 from logging import LoggerAdapter, getLogger
-from typing import Any, TypeVar
+from typing import Any, Generic, TypeVar
+from unittest.mock import Mock
 
 from bluesky.protocols import HasName
 from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
 
 from ._utils import (
     DEFAULT_TIMEOUT,
-    LazyMock,
     NotConnectedError,
     error_if_none,
     wait_for_connection,
 )
 
+DeviceT = TypeVar("DeviceT", bound="Device")
+
+
+class DeviceMock(Generic[DeviceT]):
+    """A lazily created Mock to be used when connecting in mock mode.
+
+    Creating Mocks is reasonably expensive when each Device (and Signal)
+    requires its own, and the tree is only used when ``Signal.set()`` is
+    called. This class allows a tree of lazily connected Mocks to be
+    constructed so that when the leaf is created, so are its parents.
+    Any calls to the child are then accessible from the parent mock.
+
+    Subclasses can override the `connect()` method to inject custom logic
+    when mock devices are connected.
+
+    ```python
+    >>> parent = DeviceMock()
+    >>> child = DeviceMock("child", parent)
+    >>> child_mock = child()
+    >>> child_mock()  # doctest: +ELLIPSIS
+    <Mock name='mock.child()' id='...'>
+    >>> parent_mock = parent()
+    >>> parent_mock.mock_calls
+    [call.child()]
+
+    ```
+    """
+
+    def __init__(self, name: str = "", parent: DeviceMock | None = None) -> None:
+        self.name = name
+        self.parent = parent
+        self._mock: Mock | None = None
+
+    def __call__(self) -> Mock:
+        if self._mock is None:
+            self._mock = Mock(spec=object)
+            if self.parent is not None:
+                self.parent().attach_mock(self._mock, self.name)
+        return self._mock
+
+    async def connect(self, device: DeviceT) -> None:
+        """Will be called when the device is connected in mock mode.
+
+        This allows mock values to be set and callbacks to be added
+        to the mock device so it behaves more like the real device.
+        """
+
+
+# Keep LazyMock as an alias for backwards compatibility
+# Remove for ophyd-async 1.0
+LazyMock = DeviceMock
+
 
 class DeviceConnector:
     """Defines how a `Device` should be connected and type hints processed."""
@@ -40,7 +92,7 @@ class DeviceConnector:
         during `__init__`.
         """
 
-    async def connect_mock(self, device: Device, mock: LazyMock):
+    async def connect_mock(self, device: Device, mock: DeviceMock):
         """Use during [](#Device.connect) with `mock=True`.
 
         This is called when there is no cached connect done in `mock=True`
@@ -50,12 +102,16 @@ class DeviceConnector:
         exceptions: dict[str, Exception] = {}
         for name, child_device in device.children():
             try:
-                await child_device.connect(mock=mock.child(name))
+                child_mock_class = child_device._mock_class  # noqa: SLF001
+                await child_device.connect(mock=child_mock_class(name, mock))
             except Exception as exc:
                 exceptions[name] = exc
         if exceptions:
             raise NotConnectedError.with_other_exceptions_logged(exceptions)
 
+        # Call the DeviceMock's connect method to inject custom logic
+        await mock.connect(device)
+
     async def connect_real(self, device: Device, timeout: float, force_reconnect: bool):
         """Use during [](#Device.connect) with `mock=False`.
 
@@ -82,8 +138,10 @@ class Device(HasName):
     _name: str = ""
     # None if connect hasn't started, a Task if it has
     _connect_task: asyncio.Task | None = None
+    # The mock class to be used if we connect in mock mode
+    _mock_class: type[DeviceMock] = DeviceMock
     # The mock if we have connected in mock mode
-    _mock: LazyMock | None = None
+    _mock: DeviceMock | None = None
     # The separator to use when making child names
     _child_name_separator: str = "-"
 
@@ -163,7 +221,7 @@ class Device(HasName):
 
     async def connect(
         self,
-        mock: bool | LazyMock = False,
+        mock: bool | DeviceMock = False,
         timeout: float = DEFAULT_TIMEOUT,
         force_reconnect: bool = False,
     ) -> None:
@@ -175,25 +233,26 @@ class Device(HasName):
 
         :param mock:
             If True then use [](#MockSignalBackend) for all Signals. If passed a
-            [](#LazyMock) then pass this down for use within the Signals,
-            otherwise create one.
+            [](#DeviceMock) then pass this down for use within the Signals,
+            otherwise create one using the registered default mock for this device
+            type, or a plain [](#DeviceMock) if no default is registered.
         :param timeout: Time to wait before failing with a TimeoutError.
         :param force_reconnect:
             If True, force a reconnect even if the last connect succeeded.
         """
-        connector = error_if_none(
+        connector: DeviceConnector = error_if_none(
             getattr(self, "_connector", None),
             f"{self}: doesn't have attribute `_connector`,"
             f" did you call `super().__init__` in your `__init__` method?",
         )
         if mock:
             # Always connect in mock mode serially
-            if isinstance(mock, LazyMock):
-                # Use the provided mock
+            if isinstance(mock, DeviceMock):
+                # Use the user supplied mock
                 self._mock = mock
             elif not self._mock:
-                # Make one
-                self._mock = LazyMock()
+                # Make a new mock of the registered type
+                self._mock = self._mock_class()
             await connector.connect_mock(self, self._mock)
         else:
             # Try to cache the connect in real mode
@@ -223,9 +282,6 @@ _not_device_attrs = {
 }
 
 
-DeviceT = TypeVar("DeviceT", bound=Device)
-
-
 class DeviceVector(MutableMapping[int, DeviceT], Device):
     """Defines a dictionary of Device children with arbitrary integer keys.
 
@@ -396,3 +452,23 @@ def init_devices(
             await wait_for_connection(**coros)
 
     return DeviceProcessor(process_devices)
+
+
+def default_mock_class(
+    mock_cls: type[DeviceMock],
+) -> Callable[[type[DeviceT]], type[DeviceT]]:
+    """Register a DeviceMock subclass as the default mock for a Device class.
+
+    This decorator allows automatic injection of mock logic when devices are
+    connected in mock mode. The decorated DeviceMock class should override
+    the `connect()` method to define custom mock behavior.
+
+    :param mock_cls: A DeviceMock subclass to register.
+    :returns: A decorator that registers the mock class for a Device subclass.
+    """
+
+    def wrapper(device_cls: type[DeviceT]) -> type[DeviceT]:
+        device_cls._mock_class = mock_cls  # noqa: SLF001
+        return device_cls
+
+    return wrapper

ophyd_async/core/_mock_signal_backend.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import asyncio
 from collections.abc import Callable
 from functools import cached_property
+from typing import TYPE_CHECKING
 from unittest.mock import AsyncMock
 
 from bluesky.protocols import Reading
@@ -9,7 +12,10 @@ from event_model import DataKey
 from ._derived_signal_backend import DerivedSignalBackend
 from ._signal_backend import SignalBackend, SignalDatatypeT
 from ._soft_signal_backend import SoftSignalBackend
-from ._utils import Callback, LazyMock
+from ._utils import Callback
+
+if TYPE_CHECKING:
+    from ._device import LazyMock
 
 
 class MockSignalBackend(SignalBackend[SignalDatatypeT]):

ophyd_async/{testing → core}/_mock_signal_utils.py

@@ -2,15 +2,10 @@ from collections.abc import Awaitable, Callable, Iterable, Iterator
 from contextlib import contextmanager
 from unittest.mock import AsyncMock, Mock
 
-from ophyd_async.core import (
-    Device,
-    LazyMock,
-    MockSignalBackend,
-    Signal,
-    SignalConnector,
-    SignalDatatypeT,
-    SignalR,
-)
+from ._device import Device, DeviceMock
+from ._mock_signal_backend import MockSignalBackend
+from ._signal import Signal, SignalConnector, SignalR
+from ._signal_backend import SignalDatatypeT
 
 
 def get_mock(device: Device | Signal) -> Mock:
@@ -19,16 +14,18 @@ def get_mock(device: Device | Signal) -> Mock:
     The device must have been connected in mock mode.
     """
     mock = device._mock  # noqa: SLF001
-    assert isinstance(mock, LazyMock), f"Device {device} not connected in mock mode"
+    if not isinstance(mock, DeviceMock):
+        msg = f"Device {device} not connected in mock mode"
+        raise RuntimeError(msg)
     return mock()
 
 
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:
     connector = signal._connector  # noqa: SLF001
-    assert isinstance(connector, SignalConnector), f"Expected Signal, got {signal}"
-    assert isinstance(connector.backend, MockSignalBackend), (
-        f"Signal {signal} not connected in mock mode"
-    )
+    if not isinstance(connector, SignalConnector):
+        raise TypeError(f"Expected Signal, got {signal}")
+    if not isinstance(connector.backend, MockSignalBackend):
+        raise RuntimeError(f"Signal {signal} not connected in mock mode")
     return connector.backend
 
 

ophyd_async/core/_signal.py

@@ -19,7 +19,7 @@ from bluesky.protocols import (
 from event_model import DataKey
 from stamina import retry_context
 
-from ._device import Device, DeviceConnector
+from ._device import Device, DeviceConnector, LazyMock
 from ._mock_signal_backend import MockSignalBackend
 from ._protocol import AsyncReadable, AsyncStageable
 from ._signal_backend import SignalBackend, SignalDatatypeT, SignalDatatypeV
@@ -30,7 +30,6 @@ from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     Callback,
-    LazyMock,
     T,
     error_if_none,
 )

ophyd_async/core/_utils.py

@@ -14,7 +14,6 @@ from typing import (
     get_args,
     get_origin,
 )
-from unittest.mock import Mock
 
 import numpy as np
 from pydantic import BaseModel, ConfigDict
@@ -342,45 +341,6 @@ class Reference(Generic[T]):
         return self._obj
 
 
-class LazyMock:
-    """A lazily created Mock to be used when connecting in mock mode.
-
-    Creating Mocks is reasonably expensive when each Device (and Signal)
-    requires its own, and the tree is only used when ``Signal.set()`` is
-    called. This class allows a tree of lazily connected Mocks to be
-    constructed so that when the leaf is created, so are its parents.
-    Any calls to the child are then accessible from the parent mock.
-
-    ```python
-    >>> parent = LazyMock()
-    >>> child = parent.child("child")
-    >>> child_mock = child()
-    >>> child_mock()  # doctest: +ELLIPSIS
-    <Mock name='mock.child()' id='...'>
-    >>> parent_mock = parent()
-    >>> parent_mock.mock_calls
-    [call.child()]
-
-    ```
-    """
-
-    def __init__(self, name: str = "", parent: LazyMock | None = None) -> None:
-        self.parent = parent
-        self.name = name
-        self._mock: Mock | None = None
-
-    def child(self, name: str) -> LazyMock:
-        """Return a child of this LazyMock with the given name."""
-        return LazyMock(name, self)
-
-    def __call__(self) -> Mock:
-        if self._mock is None:
-            self._mock = Mock(spec=object)
-            if self.parent is not None:
-                self.parent().attach_mock(self._mock, self.name)
-        return self._mock
-
-
 class ConfinedModel(BaseModel):
     """A base class confined to explicitly defined fields in the model schema."""
 

ophyd_async/epics/motor.py

@@ -3,6 +3,8 @@
 https://github.com/epics-modules/motor
 """
 
+from __future__ import annotations
+
 import asyncio
 
 from bluesky.protocols import (
@@ -21,18 +23,22 @@ from ophyd_async.core import (
     AsyncStatus,
     CalculatableTimeout,
     Callback,
+    DeviceMock,
     FlyMotorInfo,
     StandardReadable,
     StrictEnum,
     WatchableAsyncStatus,
     WatcherUpdate,
+    callback_on_mock_put,
+    default_mock_class,
     error_if_none,
     observe_value,
+    set_mock_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
-__all__ = ["MotorLimitsError", "Motor"]
+__all__ = ["MotorLimitsError", "Motor", "InstantMotorMock", "OffsetMode", "UseSetMode"]
 
 
 class MotorLimitsError(Exception):
@@ -61,15 +67,45 @@ def __getattr__(name):
 
 
 class OffsetMode(StrictEnum):
+    """In Set mode, determine what to do when the motor setpoint is written."""
+
     VARIABLE = "Variable"
+    """Change the offset so the readback matches the setpoint."""
     FROZEN = "Frozen"
+    """Tell the controller to change the readback without changing the offset."""
 
 
 class UseSetMode(StrictEnum):
+    """Determine what to do when the motor setpoint is written."""
+
     USE = "Use"
+    """Tell the controller to move to the setpoint."""
     SET = "Set"
+    """Change offset (in record or in controller) when setpoint is written."""
+
+
+class InstantMotorMock(DeviceMock["Motor"]):
+    """Mock behaviour that instantly moves readback to setpoint."""
+
+    async def connect(self, device: Motor) -> None:
+        """Mock signals to do an instant move on setpoint write."""
+        # Set sensible defaults to avoid runtime errors
+        set_mock_value(device.velocity, 1000)  # Prevent ZeroDivisionError
+        set_mock_value(device.max_velocity, 1000)  # Prevent ZeroDivisionError
+
+        # Motor starts in "done" state (not moving)
+        set_mock_value(device.motor_done_move, 1)
+
+        # When setpoint is written to, immediately update readback and done flag
+        def _instant_move(value, wait):
+            set_mock_value(device.motor_done_move, 0)  # Moving
+            set_mock_value(device.user_readback, value)  # Arrive instantly
+            set_mock_value(device.motor_done_move, 1)  # Done
+
+        callback_on_mock_put(device.user_setpoint, _instant_move)
 
 
+@default_mock_class(InstantMotorMock)
 class Motor(
     StandardReadable,
     Locatable[float],

ophyd_async/testing/__init__.py

@@ -13,15 +13,6 @@ from ._assert import (
     assert_value,
     partial_reading,
 )
-from ._mock_signal_utils import (
-    callback_on_mock_put,
-    get_mock,
-    get_mock_put,
-    mock_puts_blocked,
-    set_mock_put_proceeds,
-    set_mock_value,
-    set_mock_values,
-)
 from ._one_of_everything import (
     ExampleEnum,
     ExampleTable,
@@ -38,6 +29,33 @@ from ._single_derived import (
 )
 from ._wait_for_pending import wait_for_pending_wakeups
 
+
+# Back compat - delete before 1.0
+def __getattr__(name):
+    import warnings
+
+    import ophyd_async.core
+
+    moved_to_core = {
+        "callback_on_mock_put",
+        "get_mock",
+        "get_mock_put",
+        "mock_puts_blocked",
+        "set_mock_put_proceeds",
+        "set_mock_value",
+        "set_mock_values",
+    }
+    if name in moved_to_core:
+        warnings.warn(
+            DeprecationWarning(
+                f"ophyd_async.testing.{name} has moved to ophyd_async.core"
+            ),
+            stacklevel=2,
+        )
+        return getattr(ophyd_async.core, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 # The order of this list determines the order of the documentation,
 # so does not match the alphabetical order of the imports
 __all__ = [
@@ -49,14 +67,6 @@ __all__ = [
     "assert_describe_signal",
     "assert_emitted",
     "partial_reading",
-    # Mocking utilities
-    "get_mock",
-    "set_mock_value",
-    "set_mock_values",
-    "get_mock_put",
-    "callback_on_mock_put",
-    "mock_puts_blocked",
-    "set_mock_put_proceeds",
     # Wait for pending wakeups
     "wait_for_pending_wakeups",
     "ExampleEnum",

{ophyd_async-0.13.7.dist-info → ophyd_async-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.7
+Version: 0.14.0
 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.13.7.dist-info → ophyd_async-0.14.0.dist-info}/RECORD

@@ -1,32 +1,33 @@
 ophyd_async/__init__.py,sha256=dcAA3qsj1nNIMe5l-v2tlduZ_ypwBmyuHe45Lsq4k4w,206
 ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
 ophyd_async/_docs_parser.py,sha256=gPYrigfSbYCF7QoSf2UvE-cpQu4snSssl7ZWN-kKDzI,352
-ophyd_async/_version.py,sha256=JHUU2H4LQG4g5yLVtdeoRqh4fKkn1TUpLvJEVN4qjr4,706
+ophyd_async/_version.py,sha256=Byw420VruQzJ1exmj6PcZ9zpcSTgfBRBp5ZU4O6rwSc,706
 ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/core/__init__.py,sha256=yGbkVju5otO8DmA3KyerYB0gLtcX5sdxlq3ajyGha4M,5531
+ophyd_async/core/__init__.py,sha256=3YD4rtXXJy5HWBsefK0nC-j2xC5tfiFbD7KJbN3nFvw,6008
 ophyd_async/core/_derived_signal.py,sha256=TuZza_j3J1Bw4QSqBYB9Ta2FyQP5BycO3nSHVtJ890Q,13015
 ophyd_async/core/_derived_signal_backend.py,sha256=Ibce9JHghiI5Ir8w0pUYULHL2qWkobeUYc0-CDrsO2E,12615
 ophyd_async/core/_detector.py,sha256=9fYbBPmRnMGADcDTYkspDAL2uzhtNNiKCEeBUU0oKaY,14942
-ophyd_async/core/_device.py,sha256=_M3hwiYv8xO-7pfQkOzeZEEsB05Oa2HTRKOEc69C_a8,14743
+ophyd_async/core/_device.py,sha256=tm-khZLMy-Q7nn86GYHkbXRJOc83DgkbrdQ6WCjZhUs,17638
 ophyd_async/core/_device_filler.py,sha256=MDz8eQQ-eEAwo-UEMxfqPfpcBuMG01tLCGR6utwVnmE,14825
 ophyd_async/core/_enums.py,sha256=2vh6x0rZ6SLiw2xxq1xVIn-GpbLDFc8wZoVdA55QiE8,370
 ophyd_async/core/_flyer.py,sha256=8zKyU5aQOr_t59GIUwsYeb8NSabdvBp0swwuRe4v5VQ,3457
 ophyd_async/core/_hdf_dataset.py,sha256=0bIX_ZbFSMdXqDwRtEvV-0avHnwXhjPddE5GVNmo7H8,2608
 ophyd_async/core/_log.py,sha256=DxKR4Nz3SgTaTzKBZWqt-w48yT8WUAr_3Qr223TEWRw,3587
-ophyd_async/core/_mock_signal_backend.py,sha256=N6rzwBR3QwHZMcifIZg6sbno6-Ts-1jK0aFVt-3jHAg,3289
+ophyd_async/core/_mock_signal_backend.py,sha256=cFovZEwwqYKV2LuQDZStSr3TFFvA31IJeSRoheHnZ8Q,3401
+ophyd_async/core/_mock_signal_utils.py,sha256=ePFBDaon2lFT0vcnAaCRuoLr953QV6tYgHmY2fXQW-8,5520
 ophyd_async/core/_protocol.py,sha256=wQ_snxhTprHqEjQb1HgFwBljwolMY6A8C3xgV1PXwdU,4051
 ophyd_async/core/_providers.py,sha256=WBht3QCgvGc0stNcwH6z4Zr6hAz3e01-88NjsYI2w6I,9740
 ophyd_async/core/_readable.py,sha256=iBo1YwA5bsAbzLbznvmSnzKDWUuGkLh850Br3BXsgeU,11707
 ophyd_async/core/_settings.py,sha256=_ZccbXKP7j5rG6-bMKk7aaLr8hChdRDAPY_YSR71XXM,4213
-ophyd_async/core/_signal.py,sha256=LVQ38-Txn6lIYFsIbRbZClOy9WXlLDc16FdaE1wVmII,28278
+ophyd_async/core/_signal.py,sha256=OEfjW_BIC3dVxgsWC0aVUj9rQL36KHkNTBCUVXjSRFo,28274
 ophyd_async/core/_signal_backend.py,sha256=F3ma45cIIJ3D702zsVZIqn4Jv7u05YzMQBQND70QCbQ,6987
 ophyd_async/core/_soft_signal_backend.py,sha256=NJUuyaCKtBZjggt8WKi7_lKQRHasToxviuQvl5xbhLU,6222
 ophyd_async/core/_status.py,sha256=a2IDvv_GvUcFuhjQA5bQzWm9ngR6zGc9PR4XcZiaeqk,6557
 ophyd_async/core/_table.py,sha256=ryJ7AwJBglQUzwP9_aSjR8cu8EKvYXfo1q1byhke3Uc,7248
-ophyd_async/core/_utils.py,sha256=gUewO4XPrBxsEWzObNumqAB2Q7Hwrd5F_Nc6B2XwQIM,12532
+ophyd_async/core/_utils.py,sha256=xv03NYanpeKEsErZkpkkGffwdSs7UElHtJQZ--1KLz8,11207
 ophyd_async/core/_yaml_settings.py,sha256=Qojhku9l5kPSkTnEylCRWTe0gpw6S_XP5av5dPpqFgQ,2089
 ophyd_async/epics/__init__.py,sha256=ou4yEaH9VZHz70e8oM614-arLMQvUfQyXhRJsnEpWn8,60
-ophyd_async/epics/motor.py,sha256=RDcyKC_zFR5zLpAcf_yAbuY-1ImE3L3uBAoUXDEiz-s,10224
+ophyd_async/epics/motor.py,sha256=ZFr6n3IE3qW68sRwNEj_8OnJOQebmkswCMK9qXP0ZqA,11803
 ophyd_async/epics/signal.py,sha256=0A-supp9ajr63O6aD7F9oG0-Q26YmRjk-ZGh57-jo1Y,239
 ophyd_async/epics/adandor/__init__.py,sha256=dlitllrAdhvh16PAcVMUSSEytTDNMu6_HuYk8KD1EoY,343
 ophyd_async/epics/adandor/_andor.py,sha256=TijGjNVxuH-P0X7UACPt9eLLQ449DwMyVhbn1kV7Le8,1245
@@ -146,16 +147,15 @@ ophyd_async/tango/demo/_tango/_servers.py,sha256=putvERDyibibaTbhdWyqZB_axj2fURX
 ophyd_async/tango/testing/__init__.py,sha256=l52SmX9XuxZUBuLpOYJzHfskkWVYhx3RkSbGL_wUu5Y,199
 ophyd_async/tango/testing/_one_of_everything.py,sha256=eJg5K8n1ExwPfruDCHNZcWjx4aRTA1Vs_7NQHSHjpgc,6851
 ophyd_async/tango/testing/_test_config.py,sha256=i3t5d4wjUEtAvvSSZNz_bH_r5VEvUphUcEOEd8LKxQQ,228
-ophyd_async/testing/__init__.py,sha256=jDBzUAHGDMfkhd-_9u0CJWEq0E0sPrIGGlLmVzEyxY8,1742
+ophyd_async/testing/__init__.py,sha256=0x4kehIkNoR_H-gzj0yJ-SmtJxxSBnyeOcxYcNqvgkY,2033
 ophyd_async/testing/__pytest_assert_rewrite.py,sha256=_SU2UfChPgEf7CFY7aYH2B7MLp-07_qYnVLyu6QtDL8,129
 ophyd_async/testing/_assert.py,sha256=Ss_XDToi1ymUfr0Z1r45A2Fmg7-9UOv9gYkJEBsZPv8,8795
-ophyd_async/testing/_mock_signal_utils.py,sha256=GOjELaRFg9zJKcpeLFXjN7ViMT1AK2Hu52lkLMI5XUc,5393
 ophyd_async/testing/_one_of_everything.py,sha256=U9ui7B-iNHDM3H3hIWUuaCb8Gc2eLlUh0sBHUlQldT0,4741
 ophyd_async/testing/_single_derived.py,sha256=5-HOTzgePcZ354NK_ssVpyIbJoJmKyjVQCxSwQXUC-4,2730
 ophyd_async/testing/_utils.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
 ophyd_async/testing/_wait_for_pending.py,sha256=YZAR48n-CW0GsPey3zFRzMJ4byDAr3HvMIoawjmTrHw,732
-ophyd_async-0.13.7.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.13.7.dist-info/METADATA,sha256=D28G3xy4fiF7xtLVoy10CqOiI7ZLDs2z1MO6DICwVdA,5703
-ophyd_async-0.13.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ophyd_async-0.13.7.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.13.7.dist-info/RECORD,,
+ophyd_async-0.14.0.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.14.0.dist-info/METADATA,sha256=1H2TzMmCIJfib07o1qSOHNYJVDHgqkwIUn9wPjzoYNU,5703
+ophyd_async-0.14.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ophyd_async-0.14.0.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.14.0.dist-info/RECORD,,