ophyd-async 0.13.6__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.6'
-__version_tuple__ = version_tuple = (0, 13, 6)
+__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,
 )
@@ -639,9 +638,10 @@ async def set_and_wait_for_other_value(
             if wait_for_set_completion:
                 await status
         except TimeoutError as exc:
+            matcher_name = getattr(matcher, "__name__", f"<{type(matcher).__name__}>")
             raise TimeoutError(
                 f"{match_signal.name} value didn't match value from"
-                f" {matcher.__name__}() in {timeout}s"
+                f" {matcher_name}() in {timeout}s"
             ) from exc
 
     return status

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],
@@ -98,9 +134,12 @@ class Motor(
         self.motor_done_move = epics_signal_r(int, prefix + ".DMOV")
         self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
         self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
+        self.dial_low_limit_travel = epics_signal_rw(float, prefix + ".DLLM")
+        self.dial_high_limit_travel = epics_signal_rw(float, prefix + ".DHLM")
         self.offset_freeze_switch = epics_signal_rw(OffsetMode, prefix + ".FOFF")
         self.high_limit_switch = epics_signal_r(int, prefix + ".HLS")
         self.low_limit_switch = epics_signal_r(int, prefix + ".LLS")
+        self.output_link = epics_signal_r(str, prefix + ".OUT")
         self.set_use_switch = epics_signal_rw(UseSetMode, prefix + ".SET")
 
         # Note:cannot use epics_signal_x here, as the motor record specifies that
@@ -131,16 +170,26 @@ class Motor(
         Will raise a MotorLimitsException if the given absolute positions will be
         outside the motor soft limits.
         """
-        motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
+        (
+            motor_lower_limit,
+            motor_upper_limit,
+            egu,
+            dial_lower_limit,
+            dial_upper_limit,
+        ) = await asyncio.gather(
             self.low_limit_travel.get_value(),
             self.high_limit_travel.get_value(),
             self.motor_egu.get_value(),
+            self.dial_low_limit_travel.get_value(),
+            self.dial_high_limit_travel.get_value(),
         )
 
-        # EPICS motor record treats limits of 0, 0 as no limit
-        if motor_lower_limit == 0 and motor_upper_limit == 0:
+        # EPICS motor record treats dial limits of 0, 0 as no limit
+        # Use DLLM and DHLM to check
+        if dial_lower_limit == 0 and dial_upper_limit == 0:
             return
 
+        # Use real motor limit(i.e. HLM and LLM) to check if the move is permissible
         if (
             not motor_upper_limit >= abs_start_pos >= motor_lower_limit
             or not motor_upper_limit >= abs_end_pos >= motor_lower_limit
@@ -150,6 +199,8 @@ class Motor(
                 f"{abs_start_pos}{egu} to "
                 f"{abs_end_pos}{egu} but motor limits are "
                 f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+                f"dial limits are "
+                f"{dial_lower_limit}{egu} <= x <= {dial_upper_limit}"
             )
 
     @AsyncStatus.wrap

ophyd_async/epics/pmac/_pmac_io.py

@@ -6,7 +6,8 @@ from ophyd_async.core import Array1D, Device, DeviceVector, StandardReadable
 from ophyd_async.epics import motor
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
-CS_LETTERS = "ABCUVWXYZ"
+# Map the CS axis letters to their index (1 indexed)
+CS_INDEX = {letter: index + 1 for index, letter in enumerate("ABCUVWXYZ")}
 
 
 class PmacTrajectoryIO(StandardReadable):
@@ -20,24 +21,20 @@ class PmacTrajectoryIO(StandardReadable):
         # 1 indexed CS axes so we can index into them from the compound motor input link
         self.positions = DeviceVector(
             {
-                i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}{letter}:Positions"
-                )
-                for i, letter in enumerate(CS_LETTERS)
+                i: epics_signal_rw(Array1D[np.float64], f"{prefix}{letter}:Positions")
+                for letter, i in CS_INDEX.items()
             }
         )
         self.use_axis = DeviceVector(
             {
-                i + 1: epics_signal_rw(bool, f"{prefix}{letter}:UseAxis")
-                for i, letter in enumerate(CS_LETTERS)
+                i: epics_signal_rw(bool, f"{prefix}{letter}:UseAxis")
+                for letter, i in CS_INDEX.items()
             }
         )
         self.velocities = DeviceVector(
             {
-                i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}{letter}:Velocities"
-                )
-                for i, letter in enumerate(CS_LETTERS)
+                i: epics_signal_rw(Array1D[np.float64], f"{prefix}{letter}:Velocities")
+                for letter, i in CS_INDEX.items()
             }
         )
         self.total_points = epics_signal_r(int, f"{prefix}TotalPoints_RBV")
@@ -76,8 +73,8 @@ class PmacCoordIO(Device):
         self.cs_port = epics_signal_r(str, f"{prefix}Port")
         self.cs_axis_setpoint = DeviceVector(
             {
-                i + 1: epics_signal_rw(float, f"{prefix}M{i + 1}:DirectDemand")
-                for i in range(len(CS_LETTERS))
+                i: epics_signal_rw(float, f"{prefix}M{i}:DirectDemand")
+                for i in CS_INDEX.values()
             }
         )
         super().__init__(name=name)

ophyd_async/epics/pmac/_pmac_trajectory.py

@@ -15,10 +15,10 @@ from ophyd_async.core import (
     wait_for_value,
 )
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.pmac import PmacIO
-from ophyd_async.epics.pmac._pmac_io import CS_LETTERS
-from ophyd_async.epics.pmac._pmac_trajectory_generation import PVT, Trajectory
-from ophyd_async.epics.pmac._utils import (
+
+from ._pmac_io import CS_INDEX, PmacIO
+from ._pmac_trajectory_generation import PVT, Trajectory
+from ._utils import (
     _PmacMotorInfo,
     calculate_ramp_position_and_duration,
 )
@@ -131,8 +131,7 @@ class PmacTrajectoryTriggerLogic(FlyerController):
             slice, path_length, motor_info, ramp_up_time
         )
         use_axis = {
-            axis + 1: (axis in motor_info.motor_cs_index.values())
-            for axis in range(len(CS_LETTERS))
+            i: (i in motor_info.motor_cs_index.values()) for i in CS_INDEX.values()
         }
 
         coros = [
@@ -177,14 +176,14 @@ class PmacTrajectoryTriggerLogic(FlyerController):
         self, trajectory: Trajectory, motor_info: _PmacMotorInfo
     ):
         coros = []
-        for motor, number in motor_info.motor_cs_index.items():
+        for motor, cs_index in motor_info.motor_cs_index.items():
             coros.append(
-                self.pmac.trajectory.positions[number + 1].set(
+                self.pmac.trajectory.positions[cs_index].set(
                     trajectory.positions[motor]
                 )
             )
             coros.append(
-                self.pmac.trajectory.velocities[number + 1].set(
+                self.pmac.trajectory.velocities[cs_index].set(
                     trajectory.velocities[motor]
                 )
             )
@@ -206,7 +205,7 @@ class PmacTrajectoryTriggerLogic(FlyerController):
         for motor, position in ramp_up_position.items():
             coros.append(
                 set_and_wait_for_value(
-                    coord.cs_axis_setpoint[motor_info.motor_cs_index[motor] + 1],
+                    coord.cs_axis_setpoint[motor_info.motor_cs_index[motor]],
                     position,
                     set_timeout=10,
                     wait_for_set_completion=False,

ophyd_async/epics/pmac/_utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import re
 from collections.abc import Sequence
 from dataclasses import dataclass
 
@@ -10,7 +11,7 @@ from scanspec.core import Slice
 from ophyd_async.core import gather_dict
 from ophyd_async.epics.motor import Motor
 
-from ._pmac_io import CS_LETTERS, PmacIO
+from ._pmac_io import CS_INDEX, PmacIO
 
 # PMAC durations are in milliseconds
 # We must convert from scanspec durations (seconds) to milliseconds
@@ -21,6 +22,11 @@ TICK_S = 0.000001
 MIN_TURNAROUND = 0.002
 MIN_INTERVAL = 0.002
 
+# Regex to parse outlink strings of the form "@asyn(PMAC1CS2, 7)"
+# returning PMAC1CS2 and 7
+# https://regex101.com/r/Mu9XpO/1
+OUTLINK_REGEX = re.compile(r"^\@asyn\(([^,]+),\s*(\d+)\)$")
+
 
 @dataclass
 class _PmacMotorInfo:
@@ -44,78 +50,115 @@ class _PmacMotorInfo:
             dictionaries of motor's to their unique CS index and accelerate rate
 
         """
-        assignments = {
-            motor: pmac.assignment[pmac.motor_assignment_index[motor]]
-            for motor in motors
-        }
-
-        cs_ports, cs_numbers, cs_axes, velocities, accls = await asyncio.gather(
-            gather_dict(
-                {motor: assignments[motor].cs_port.get_value() for motor in motors}
-            ),
-            gather_dict(
-                {motor: assignments[motor].cs_number.get_value() for motor in motors}
-            ),
-            gather_dict(
-                {
-                    motor: assignments[motor].cs_axis_letter.get_value()
-                    for motor in motors
-                }
-            ),
-            gather_dict({motor: motor.max_velocity.get_value() for motor in motors}),
-            gather_dict(
-                {motor: motor.acceleration_time.get_value() for motor in motors}
-            ),
-        )
+        is_raw_motor = [motor in pmac.motor_assignment_index for motor in motors]
+        if all(is_raw_motor):
+            # Get the CS port, number and axis letter from the PVs for the raw motor
+            assignments = {
+                motor: pmac.assignment[pmac.motor_assignment_index[motor]]
+                for motor in motors
+            }
+            cs_ports, cs_numbers, cs_axis_letters = await asyncio.gather(
+                gather_dict(
+                    {motor: assignments[motor].cs_port.get_value() for motor in motors}
+                ),
+                gather_dict(
+                    {
+                        motor: assignments[motor].cs_number.get_value()
+                        for motor in motors
+                    }
+                ),
+                gather_dict(
+                    {
+                        motor: assignments[motor].cs_axis_letter.get_value()
+                        for motor in motors
+                    }
+                ),
+            )
+            # Translate axis letters to cs_index and check for duplicates
+            motor_cs_index: dict[Motor, int] = {}
+            for motor, cs_axis_letter in cs_axis_letters.items():
+                if not cs_axis_letter:
+                    raise ValueError(
+                        f"Motor {motor.name} does not have an axis assignment."
+                    )
+                try:
+                    # 1 indexed to match coord
+                    index = CS_INDEX[cs_axis_letter]
+                except KeyError as err:
+                    raise ValueError(
+                        f"Motor {motor.name} assigned to '{cs_axis_letter}' "
+                        f"but must be assigned to one of '{','.join(CS_INDEX)}'"
+                    ) from err
+                if index in motor_cs_index.values():
+                    raise ValueError(
+                        f"Motor {motor.name} assigned to '{cs_axis_letter}' "
+                        "but another motor is already assigned to this axis."
+                    )
+                motor_cs_index[motor] = index
+        elif not any(is_raw_motor):
+            # Get CS numbers from all the cs ports and output links for the CS motors
+            output_links, cs_lookup = await asyncio.gather(
+                gather_dict({motor: motor.output_link.get_value() for motor in motors}),
+                gather_dict(
+                    {
+                        cs_number: cs.cs_port.get_value()
+                        for cs_number, cs in pmac.coord.items()
+                    }
+                ),
+            )
+            # Create a reverse lookup from cs_port to cs_number
+            cs_reverse_lookup = {
+                cs_port: cs_number for cs_number, cs_port in cs_lookup.items()
+            }
+            cs_ports: dict[Motor, str] = {}
+            cs_numbers: dict[Motor, int] = {}
+            motor_cs_index: dict[Motor, int] = {}
+            # Populate the cs_ports, cs_numbers and motor_cs_index dicts from outlinks
+            for motor, output_link in output_links.items():
+                match = OUTLINK_REGEX.match(output_link)
+                if not match:
+                    raise ValueError(
+                        f"Motor {motor.name} has invalid output link '{output_link}'"
+                    )
+                cs_port, cs_index = match.groups()
+                cs_ports[motor] = cs_port
+                cs_numbers[motor] = cs_reverse_lookup[cs_port]
+                motor_cs_index[motor] = int(cs_index)
+        else:
+            raise ValueError("Unable to use raw motors and CS motors in the same scan")
 
         # check if the values in cs_port and cs_number are the same
-        cs_ports = set(cs_ports.values())
-
-        if len(cs_ports) != 1:
+        cs_ports_set = set(cs_ports.values())
+        if len(cs_ports_set) != 1:
             raise RuntimeError(
                 "Failed to fetch common CS port."
                 "Motors passed are assigned to multiple CS ports:"
-                f"{list(cs_ports)}"
+                f"{list(cs_ports_set)}"
             )
-
-        cs_port = cs_ports.pop()
-
-        cs_numbers = set(cs_numbers.values())
-        if len(cs_numbers) != 1:
+        cs_numbers_set = set(cs_numbers.values())
+        if len(cs_numbers_set) != 1:
             raise RuntimeError(
                 "Failed to fetch common CS number."
                 "Motors passed are assigned to multiple CS numbers:"
-                f"{list(cs_numbers)}"
+                f"{list(cs_numbers_set)}"
             )
 
-        cs_number = cs_numbers.pop()
-
-        motor_cs_index = {}
-        for motor in cs_axes:
-            try:
-                if not cs_axes[motor]:
-                    raise ValueError
-                motor_cs_index[motor] = CS_LETTERS.index(cs_axes[motor])
-            except ValueError as err:
-                raise ValueError(
-                    "Failed to get motor CS index. "
-                    f"Motor {motor.name} assigned to '{cs_axes[motor]}' "
-                    f"but must be assignmed to '{CS_LETTERS}"
-                ) from err
-            if len(set(motor_cs_index.values())) != len(motor_cs_index.items()):
-                raise RuntimeError(
-                    "Failed to fetch distinct CS Axes."
-                    "Motors passed are assigned to the same CS Axis"
-                    f"{list(motor_cs_index)}"
-                )
-
+        # Get the velocities and acceleration rates for each motor
+        max_velocity, acceleration_time = await asyncio.gather(
+            gather_dict({motor: motor.max_velocity.get_value() for motor in motors}),
+            gather_dict(
+                {motor: motor.acceleration_time.get_value() for motor in motors}
+            ),
+        )
         motor_acceleration_rate = {
-            motor: float(velocities[motor]) / float(accls[motor])
-            for motor in velocities
+            motor: max_velocity[motor] / acceleration_time[motor] for motor in motors
         }
-
         return _PmacMotorInfo(
-            cs_port, cs_number, motor_cs_index, motor_acceleration_rate, velocities
+            cs_port=cs_ports_set.pop(),
+            cs_number=cs_numbers_set.pop(),
+            motor_cs_index=motor_cs_index,
+            motor_acceleration_rate=motor_acceleration_rate,
+            motor_max_velocity=max_velocity,
         )
 
 

ophyd_async/tango/core/__init__.py

@@ -8,7 +8,6 @@ from ._signal import (
     tango_signal_w,
     tango_signal_x,
 )
-from ._tango_readable import TangoReadable
 from ._tango_transport import (
     AttributeProxy,
     CommandProxy,
@@ -50,7 +49,6 @@ __all__ = [
     "tango_signal_w",
     "tango_signal_x",
     "TangoDevice",
-    "TangoReadable",
     "TangoPolling",
     "TangoDeviceConnector",
     "TangoLongStringTable",

ophyd_async/tango/core/_base_device.py

@@ -29,7 +29,7 @@ class TangoDevice(Device):
 
     def __init__(
         self,
-        trl: str | None,
+        trl: str = "",
         support_events: bool = False,
         name: str = "",
         auto_fill_signals: bool = True,
@@ -80,6 +80,9 @@ class TangoDeviceConnector(DeviceConnector):
         self._support_events = support_events
         self._auto_fill_signals = auto_fill_signals
 
+    def set_trl(self, trl: str):
+        self.trl = trl
+
     def create_children_from_annotations(self, device: Device):
         if not hasattr(self, "filler"):
             self.filler = DeviceFiller(

ophyd_async/tango/demo/_counter.py

@@ -1,11 +1,18 @@
 from typing import Annotated as A
 
-from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, SignalR, SignalRW, SignalX
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StandardReadable,
+)
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.tango.core import TangoPolling, TangoReadable
+from ophyd_async.tango.core import TangoDevice, TangoPolling
 
 
-class TangoCounter(TangoReadable):
+class TangoCounter(TangoDevice, StandardReadable):
     """Tango counting device."""
 
     # Enter the name and type of the signals you want to use

ophyd_async/tango/demo/_mover.py

@@ -11,16 +11,17 @@ from ophyd_async.core import (
     SignalR,
     SignalRW,
     SignalX,
+    StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
     wait_for_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.tango.core import DevStateEnum, TangoPolling, TangoReadable
+from ophyd_async.tango.core import DevStateEnum, TangoDevice, TangoPolling
 
 
-class TangoMover(TangoReadable, Movable, Stoppable):
+class TangoMover(TangoDevice, StandardReadable, Movable, Stoppable):
     """Tango moving device."""
 
     # Enter the name and type of the signals you want to use
@@ -32,7 +33,7 @@ class TangoMover(TangoReadable, Movable, Stoppable):
     # If a tango name clashes with a bluesky verb, add a trailing underscore
     stop_: SignalX
 
-    def __init__(self, trl: str | None = "", name=""):
+    def __init__(self, trl: str = "", name=""):
         super().__init__(trl, name=name)
         self.add_readables([self.position], Format.HINTED_SIGNAL)
         self.add_readables([self.velocity], Format.CONFIG_SIGNAL)

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.6.dist-info → ophyd_async-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.6
+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.6.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=opPR5vtgMqtAtI-1B5Bg_MEreSc0tb9JwaQhHrD7xNE,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=085vcyjhEyZECi4Svjq6DUM5kxrzZh8s5DoHR2LALOc,28195
+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=nS6Vx4-6vYso3b_QtpE8p8dlys5jRr2LK7prZCkZMc8,9558
+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
@@ -83,10 +84,10 @@ ophyd_async/epics/demo/point_detector_channel.db,sha256=FZ9H6HjqplhcF2jgimv_dT1n
 ophyd_async/epics/odin/__init__.py,sha256=7kRqVzwoD8PVtp7Nj9iQWlgbLeoWE_8oiq-B0kixwTE,93
 ophyd_async/epics/odin/_odin_io.py,sha256=YDBrS15PnEKe5SHmz397Emh--lZSQEnbR3G7p8pbShY,6533
 ophyd_async/epics/pmac/__init__.py,sha256=GqJTiJudqE9pu050ZNED09F9tKRfazn0wBsojsMH2gg,273
-ophyd_async/epics/pmac/_pmac_io.py,sha256=E7tdaq9FAM6BeGQG1L8ALEYpXOlyqTXl_NLLSWzmCdk,4345
-ophyd_async/epics/pmac/_pmac_trajectory.py,sha256=7wTaetNNy9uj7C_skcs0VH5BthuY4Ec5zn-m4ROxd8k,7866
+ophyd_async/epics/pmac/_pmac_io.py,sha256=cbChieNrDWRzrr5Mdsqtm2Azp8sG0KHP9rGeJxmbYrA,4332
+ophyd_async/epics/pmac/_pmac_trajectory.py,sha256=hzAcpLNmFoNceubsjk6mjsmg6-PgSjWUu1a8Exyvi6I,7729
 ophyd_async/epics/pmac/_pmac_trajectory_generation.py,sha256=3IIxXa0r6-2uNnILKLGxp3xosOZx8MubKF-F_OM7uaw,27331
-ophyd_async/epics/pmac/_utils.py,sha256=n4vh9n7hmaWe9g02FtguF2oDsYuVvsTgmK7fYEyGuIE,6092
+ophyd_async/epics/pmac/_utils.py,sha256=MfuY6NicT7wkwVIWAZkWoCu1ZoSzy6jda1wLK9XAOLA,8614
 ophyd_async/epics/testing/__init__.py,sha256=aTIv4D2DYrpnGco5RQF8QuLG1SfFkIlTyM2uYEKXltA,522
 ophyd_async/epics/testing/_example_ioc.py,sha256=zb4ZEUzuB2MrSw5ETPLIiHhf-2BRU1Bdxco6Kh4iI1I,3880
 ophyd_async/epics/testing/_utils.py,sha256=9gxpwaWX0HGtacu1LTupcw7viXN8G78RmuNciU_-cjs,1702
@@ -131,32 +132,30 @@ ophyd_async/sim/_pattern_generator.py,sha256=kuxvyX2gIxrywhQRhaO1g8YluBT7LBkE20I
 ophyd_async/sim/_point_detector.py,sha256=wMG_ncvm99WMCPihlFyuMEf3UknAxCpB1hpk3uKiENE,3024
 ophyd_async/sim/_stage.py,sha256=_SywbmSQwxf7JLx68qwo0RpiB3oIWlbTLmvRKxUoig0,1602
 ophyd_async/tango/__init__.py,sha256=g9xzjlzPpUAP12YI-kYwfAoLSYPAQdL1S11R2c-cius,60
-ophyd_async/tango/core/__init__.py,sha256=OOVdHu07cssK90F-caG0CY7qKpPYy0MSV421YNAI-_8,1413
-ophyd_async/tango/core/_base_device.py,sha256=e9oqSL-fDOj8r9nUUFZkbibhRGbI6HYtlnZjK5B_2fE,5033
+ophyd_async/tango/core/__init__.py,sha256=dO2tG_y61zZFQRQh5L37Ps-IqNf-DGOT77Ov5Kobfhs,1349
+ophyd_async/tango/core/_base_device.py,sha256=X5ncxaWKOfRhhqPyT8tmTBJGc3ldGthw1ZCe_j_M2Tg,5088
 ophyd_async/tango/core/_converters.py,sha256=xI_RhMR8dY6IVORUZVVCL9LdYnEE6TA6BBPX_lTu06w,2183
 ophyd_async/tango/core/_signal.py,sha256=8mIxRVEVjhDN33LDbbKZWGMUYn9Gl5ZMEIYw6GSBTUE,5569
-ophyd_async/tango/core/_tango_readable.py,sha256=ctR6YcBGGatW6Jp2kvddA1hVZ2v1CidPsF9FmJK9BYg,406
 ophyd_async/tango/core/_tango_transport.py,sha256=KxjhHqKADrOvzGi9tbOQXUWdsJ0NKGejWxHItxpUsjg,37401
 ophyd_async/tango/core/_utils.py,sha256=pwT7V1DNWSyPOSzvDZ6OsDZTjaV-pAeDLDlmgtHVcNM,1673
 ophyd_async/tango/demo/__init__.py,sha256=_j-UicTnckuIBp8PnieFMOMnLFGivnaKdmo9o0hYtzc,256
-ophyd_async/tango/demo/_counter.py,sha256=2J4SCHnBWLF0O5mFWlJdO4tmnElvlx5sRrk4op_AC9U,1139
+ophyd_async/tango/demo/_counter.py,sha256=m6zxOJLbHgCEBAapVc1UiOOqKj5lvrlxjA6mXWMRMjo,1200
 ophyd_async/tango/demo/_detector.py,sha256=X5YWHAjukKZ7iYF1fBNle4CBDj1X5rvj0lnPMOcnRCU,1340
-ophyd_async/tango/demo/_mover.py,sha256=i-Tq5nDmYi4RcC4O6mOJoVeMEIIxuqyS_2AfjTpAcnk,2884
+ophyd_async/tango/demo/_mover.py,sha256=FyG9g1TLaWoqjbLblqWK8inMuDcNVlioq0MIeD5npz4,2913
 ophyd_async/tango/demo/_tango/__init__.py,sha256=FfONT7vM49nNo3a1Lv-LcMZO9EHv6bv91yY-RnxIib4,85
 ophyd_async/tango/demo/_tango/_servers.py,sha256=putvERDyibibaTbhdWyqZB_axj2fURXqzDsZb9oSW14,2991
 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.6.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.13.6.dist-info/METADATA,sha256=o3yNVUgIIR1UiWECtmQX9WZLuZAu4et3sru1DKoOsDM,5703
-ophyd_async-0.13.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ophyd_async-0.13.6.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.13.6.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,,

ophyd_async/tango/core/_tango_readable.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from ophyd_async.core import StandardReadable
-
-from ._base_device import TangoDevice
-
-
-class TangoReadable(TangoDevice, StandardReadable):
-    def __init__(
-        self,
-        trl: str | None = None,
-        name: str = "",
-        auto_fill_signals: bool = True,
-    ) -> None:
-        TangoDevice.__init__(self, trl, name=name, auto_fill_signals=auto_fill_signals)