ophyd-async 0.13.7__py3-none-any.whl → 0.14.1__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.1'
+__version_tuple__ = version_tuple = (0, 14, 1)
 
 __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,10 +35,20 @@ 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,
     AutoIncrementingPathProvider,
+    AutoMaxIncrementingPathProvider,
     DatasetDescriber,
     FilenameProvider,
     PathInfo,
@@ -87,7 +105,6 @@ from ._utils import (
     Callback,
     ConfinedModel,
     EnumTypes,
-    LazyMock,
     NotConnectedError,
     Reference,
     StrictEnum,
@@ -166,8 +183,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",
@@ -196,6 +223,7 @@ __all__ = [
     "FilenameProvider",
     "StaticFilenameProvider",
     "AutoIncrementFilenameProvider",
+    "AutoMaxIncrementingPathProvider",
     "UUIDFilenameProvider",
     # Datatset
     "DatasetDescriber",

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/_providers.py

@@ -1,9 +1,10 @@
+import re
 import uuid
 from abc import abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import date
-from pathlib import PurePath, PureWindowsPath
+from pathlib import Path, PurePath, PureWindowsPath
 from typing import Protocol
 from urllib.parse import urlunparse
 
@@ -157,6 +158,98 @@ class StaticPathProvider(PathProvider):
         )
 
 
+class AutoMaxIncrementingPathProvider(PathProvider):
+    """Increment directory name on each call by checking existing directories.
+
+    Looks through directories in a specified base path to increment directory name.
+    PathInfo gives path like base_path/0001_dirname/dirname, or
+    base_path/yyyy-mm-dd/0001_dirname/dirname if dated is true. Here,
+    the '0001' is the value which gets incremented if the file exists already.
+
+    It's recommended for the base path provider to be non-incrementing.
+
+    Args:
+    base_path_provider: Path to create directories inside of. Note that the filename of
+    this provider is used as the top level directory and the filename
+    max_digits: Number of digits to pad onto the parent directory.
+    starting_value: Number to start incrementing from.
+    dated: Whether to create an extra directory to specify the day.
+
+    """
+
+    def __init__(
+        self,
+        base_path_provider: PathProvider,
+        max_digits: int = 4,
+        starting_value: int = 0,
+        dated: bool = False,
+    ):
+        self._base_path_provider = base_path_provider
+        self._max_digits = max_digits
+        self._next_value = starting_value
+        self._dated = dated
+
+    def _get_highest_number_from(self, path: Path) -> int:
+        # Look through directories in path which end in "_{number} and get highest
+        # number"
+        highest_number = 0
+        candidates = [
+            x for x in path.iterdir() if x.is_dir() and re.match(r"^\d+_", x.name)
+        ]
+        if candidates:
+            highest_number = max(
+                int(x.name.split("_", maxsplit=1)[0]) for x in candidates
+            )
+        else:
+            highest_number = self._next_value
+        return highest_number
+
+    def __call__(self, device_name: str | None = None) -> PathInfo:
+        base_path_info = self._base_path_provider.__call__()
+        base_path_dir = Path(base_path_info.directory_path)
+        if self._dated:
+            # Make sure we are the max ID of any other days to keep numbering
+            # consistent.
+            cands = [
+                self._get_highest_number_from(x)
+                for x in base_path_dir.iterdir()
+                if re.match(r"^\d\d\d\d-\d\d-\d\d$", x.name)
+            ]
+            if cands:
+                self._next_value = max(max(cands) + 1, self._next_value)
+
+            path = base_path_dir / date.today().strftime("%Y-%m-%d")
+        else:
+            path = base_path_dir
+
+        val_to_use = self._next_value
+
+        # Get the highest number using files in path, or use
+        # stored next value if no files are found.
+        if path.exists():
+            highest_number = self._get_highest_number_from(path)
+            val_to_use = (
+                highest_number + 1
+                if not highest_number == self._next_value
+                else highest_number
+            )
+
+        self._next_value = val_to_use + 1
+
+        filename = base_path_info.filename
+
+        padded_counter = f"{val_to_use:0{self._max_digits}}"
+        full_path = (
+            path / f"{padded_counter}_{filename.strip('_')}" / filename.rstrip("_")
+        )
+        return PathInfo(
+            directory_path=full_path.parent,
+            directory_uri=None,
+            filename=full_path.name,
+            create_dir_depth=0,
+        )
+
+
 class AutoIncrementingPathProvider(PathProvider):
     """Provides a new numerically incremented path on each call."""
 

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/epics/pmac/_pmac_trajectory.py

@@ -10,6 +10,7 @@ from ophyd_async.core import (
     AsyncStatus,
     FlyerController,
     error_if_none,
+    gather_dict,
     observe_value,
     set_and_wait_for_value,
     wait_for_value,
@@ -202,12 +203,25 @@ class PmacTrajectoryTriggerLogic(FlyerController):
         coord = self.pmac.coord[motor_info.cs_number]
         coros = []
         await coord.defer_moves.set(True)
+
+        motor_readbacks = await gather_dict(
+            {motor: motor.user_readback.get_value() for motor in ramp_up_position}
+        )
+
+        move_times = [
+            abs(position - motor_readbacks[motor])
+            / motor_info.motor_max_velocity[motor]
+            for motor, position in ramp_up_position.items()
+        ]
+
+        longest_time = max(move_times)
+
         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]],
                     position,
-                    set_timeout=10,
+                    set_timeout=longest_time + DEFAULT_TIMEOUT,
                     wait_for_set_completion=False,
                 )
             )

ophyd_async/fastcs/eiger/_eiger_io.py

@@ -29,7 +29,7 @@ class EigerDetectorIO(Device):
     frame_time: SignalRW[float]
     nimages: SignalRW[int]
     ntrigger: SignalRW[int]
-    nexpi: SignalRW[int]
+    nexpi: SignalRW[int] | None
     trigger_mode: SignalRW[str]
     roi_mode: SignalRW[str]
     photon_energy: SignalRW[float]

ophyd_async/fastcs/panda/_control.py

@@ -35,7 +35,8 @@ class PandaPcapController(DetectorController):
         await wait_for_value(self.pcap.active, True, timeout=1)
 
     async def wait_for_idle(self):
-        pass
+        if self._arm_status and not self._arm_status.done:
+            await self._arm_status
 
     async def disarm(self):
         await self.pcap.arm.set(False)

ophyd_async/tango/core/__init__.py

@@ -9,7 +9,9 @@ from ._signal import (
     tango_signal_x,
 )
 from ._tango_transport import (
+    AttributeInfoEx,
     AttributeProxy,
+    CommandInfo,
     CommandProxy,
     CommandProxyReadCharacter,
     TangoDoubleStringTable,
@@ -21,6 +23,7 @@ from ._tango_transport import (
     get_python_type,
     get_source_metadata,
     get_tango_trl,
+    parse_precision,
 )
 from ._utils import (
     DevStateEnum,
@@ -30,7 +33,9 @@ from ._utils import (
 )
 
 __all__ = [
+    "AttributeInfoEx",
     "AttributeProxy",
+    "CommandInfo",
     "CommandProxy",
     "CommandProxyReadCharacter",
     "DevStateEnum",
@@ -44,6 +49,7 @@ __all__ = [
     "infer_python_type",
     "infer_signal_type",
     "make_backend",
+    "parse_precision",
     "tango_signal_r",
     "tango_signal_rw",
     "tango_signal_w",

ophyd_async/tango/core/_tango_transport.py

@@ -1,6 +1,7 @@
 import asyncio
 import functools
 import logging
+import re
 import time
 from abc import abstractmethod
 from collections.abc import Callable, Coroutine, Sequence
@@ -582,6 +583,15 @@ class CommandProxy(TangoProxy):
         pass
 
 
+PRECISION_PATTERN = re.compile(r"%\d*\.(\d+)f")
+
+
+def parse_precision(config: AttributeInfoEx):
+    if config.format and (matches := PRECISION_PATTERN.findall(config.format)):
+        return int(matches[0])
+    return None
+
+
 def get_dtype_extended(datatype) -> object | None:
     """For converting tango types to numpy datatype formats."""
     # DevState tango type does not have numpy equivalents
@@ -639,17 +649,8 @@ def get_source_metadata(
             if tr_dtype == CmdArgType.DevState:
                 _choices = list(DevState.names.keys())
 
-            _precision = None
-            if config.format:
-                try:
-                    _precision = int(config.format.split(".")[1].split("f")[0])
-                except (ValueError, IndexError) as exc:
-                    # If parsing config.format fails, _precision remains None.
-                    logger.warning(
-                        "Failed to parse precision from config.format: %s. Error: %s",
-                        config.format,
-                        exc,
-                    )
+            _precision = parse_precision(config)
+
             no_limits = Limits(
                 control=LimitsRange(high=None, low=None),
                 warning=LimitsRange(high=None, low=None),

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.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.7
+Version: 0.14.1
 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.1.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=a3VJZDtDsD7dO22j4y92zbdkUlJwzXf_QabiVquJm1Y,706
 ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/core/__init__.py,sha256=yGbkVju5otO8DmA3KyerYB0gLtcX5sdxlq3ajyGha4M,5531
+ophyd_async/core/__init__.py,sha256=GJxLNTxXD3Qlghq6CNe-mCeludgBBpHkHXkbDFojdHQ,6084
 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/_providers.py,sha256=IO6xlAVQLkbECT96ezgzoDfZ_OhbD9NrDdXvEcyWJkI,13087
 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
@@ -84,7 +85,7 @@ ophyd_async/epics/odin/__init__.py,sha256=7kRqVzwoD8PVtp7Nj9iQWlgbLeoWE_8oiq-B0k
 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=cbChieNrDWRzrr5Mdsqtm2Azp8sG0KHP9rGeJxmbYrA,4332
-ophyd_async/epics/pmac/_pmac_trajectory.py,sha256=hzAcpLNmFoNceubsjk6mjsmg6-PgSjWUu1a8Exyvi6I,7729
+ophyd_async/epics/pmac/_pmac_trajectory.py,sha256=DzO6gfvbK8M3Ec6vq0WTlz0RRYGNzP8qDJIMWTWJeLo,8150
 ophyd_async/epics/pmac/_pmac_trajectory_generation.py,sha256=3IIxXa0r6-2uNnILKLGxp3xosOZx8MubKF-F_OM7uaw,27331
 ophyd_async/epics/pmac/_utils.py,sha256=MfuY6NicT7wkwVIWAZkWoCu1ZoSzy6jda1wLK9XAOLA,8614
 ophyd_async/epics/testing/__init__.py,sha256=aTIv4D2DYrpnGco5RQF8QuLG1SfFkIlTyM2uYEKXltA,522
@@ -97,7 +98,7 @@ ophyd_async/fastcs/core.py,sha256=pL_srtTrfuoBHUjDFpxES92owFq9M4Jve0Skk1oeuFA,51
 ophyd_async/fastcs/eiger/__init__.py,sha256=RxwOFjERKy5tUD_IDGCGuMh716FaZgCq7R9elPixBwo,312
 ophyd_async/fastcs/eiger/_eiger.py,sha256=jo3K5dM3Co_RDYIyO6poCVDqp2g_1z4MqnYftwnMhUk,1103
 ophyd_async/fastcs/eiger/_eiger_controller.py,sha256=Cucj-1M-1CaxSJxHZmHs3f_OXwtTIspcqUFhRNGzn_E,2361
-ophyd_async/fastcs/eiger/_eiger_io.py,sha256=yNozTKX4CMoqIaFvyKJEs5RXXGJ4VITP_T4TIFHWRmc,1242
+ophyd_async/fastcs/eiger/_eiger_io.py,sha256=mVgDC296B4RkSObWBiA7AXtVRTQw388lJPw2roQctFs,1249
 ophyd_async/fastcs/jungfrau/__init__.py,sha256=xwTaPiqvtyyljP2acz07FSlUW79Io8EsKks9ENgbumA,765
 ophyd_async/fastcs/jungfrau/_controller.py,sha256=TvUxRuP3NJFTOcyHeMn5-1Va7HzOJswWCYSGdp1NMFI,5778
 ophyd_async/fastcs/jungfrau/_jungfrau.py,sha256=KAHCmRHMyzIh-r2JXVJcQOGLkCOOdW5Mao_KChITO2s,929
@@ -106,7 +107,7 @@ ophyd_async/fastcs/jungfrau/_utils.py,sha256=QpdWbPT_31Jwyi7INFMRq9hncSZIK_4J3l6
 ophyd_async/fastcs/odin/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
 ophyd_async/fastcs/panda/__init__.py,sha256=GbnPqH_13wvyPK1CvRHGAViamKVWHY9n-sTmfAdcnMA,1229
 ophyd_async/fastcs/panda/_block.py,sha256=Bffta9IkuSq_NSvidDvLyC1YUrfQCwMhppsu1Te7vec,2679
-ophyd_async/fastcs/panda/_control.py,sha256=xtW3dH_MLQoycgP-4vJtYx1M9alHjWo13iu9UFTgwzY,1306
+ophyd_async/fastcs/panda/_control.py,sha256=lUogRZMkQk4eZFghTuhwSDLqxR16-DQvx9MyFpg10Qc,1387
 ophyd_async/fastcs/panda/_hdf_panda.py,sha256=tL_OWHxlMQcMZGq9sxHLSeag6hP9MRIbTPn1W0u0iNI,1237
 ophyd_async/fastcs/panda/_table.py,sha256=maKGoKypEuYqTSVWGgDO6GMEKOtlDm9Dn5YiYdBzu6c,2486
 ophyd_async/fastcs/panda/_trigger.py,sha256=iBxW4YMfRYrpg7AoQaHb7rHKCE95UbSxguRuR9FOgw8,7610
@@ -131,11 +132,11 @@ 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=dO2tG_y61zZFQRQh5L37Ps-IqNf-DGOT77Ov5Kobfhs,1349
+ophyd_async/tango/core/__init__.py,sha256=cgO5GWfEZqjH0Aj9KUeoZwxMrOQOTn9V9kaYel7j0x4,1473
 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_transport.py,sha256=KxjhHqKADrOvzGi9tbOQXUWdsJ0NKGejWxHItxpUsjg,37401
+ophyd_async/tango/core/_tango_transport.py,sha256=fPICZzsF9Rf53sHtM3NXlKmhF-8CNO2prra3msD74R0,37177
 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=m6zxOJLbHgCEBAapVc1UiOOqKj5lvrlxjA6mXWMRMjo,1200
@@ -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.1.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.14.1.dist-info/METADATA,sha256=I2Y_2-lFXNeZYNYDhNxPvrubLM8bd8d5OzPbPzdn0mM,5703
+ophyd_async-0.14.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ophyd_async-0.14.1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.14.1.dist-info/RECORD,,