ophyd-async 0.8.0a2__py3-none-any.whl → 0.8.0a4__py3-none-any.whl

ophyd_async/core/_mock_signal_backend.py

@@ -1,13 +1,13 @@
 import asyncio
 from collections.abc import Callable
 from functools import cached_property
-from unittest.mock import AsyncMock, Mock
+from unittest.mock import AsyncMock
 
 from bluesky.protocols import Descriptor, Reading
 
 from ._signal_backend import SignalBackend, SignalDatatypeT
 from ._soft_signal_backend import SoftSignalBackend
-from ._utils import Callback
+from ._utils import Callback, LazyMock
 
 
 class MockSignalBackend(SignalBackend[SignalDatatypeT]):
@@ -16,7 +16,7 @@ class MockSignalBackend(SignalBackend[SignalDatatypeT]):
     def __init__(
         self,
         initial_backend: SignalBackend[SignalDatatypeT],
-        mock: Mock,
+        mock: LazyMock,
     ) -> None:
         if isinstance(initial_backend, MockSignalBackend):
             raise ValueError("Cannot make a MockSignalBackend for a MockSignalBackend")
@@ -34,11 +34,14 @@ class MockSignalBackend(SignalBackend[SignalDatatypeT]):
 
         # use existing Mock if provided
         self.mock = mock
-        self.put_mock = AsyncMock(name="put", spec=Callable)
-        self.mock.attach_mock(self.put_mock, "put")
-
         super().__init__(datatype=self.initial_backend.datatype)
 
+    @cached_property
+    def put_mock(self) -> AsyncMock:
+        put_mock = AsyncMock(name="put", spec=Callable)
+        self.mock().attach_mock(put_mock, "put")
+        return put_mock
+
     def set_value(self, value: SignalDatatypeT):
         self.soft_backend.set_value(value)
 
@@ -46,7 +49,7 @@ class MockSignalBackend(SignalBackend[SignalDatatypeT]):
         return f"mock+{self.initial_backend.source(name, read)}"
 
     async def connect(self, timeout: float) -> None:
-        pass
+        raise RuntimeError("It is not possible to connect a MockSignalBackend")
 
     @cached_property
     def put_proceeds(self) -> asyncio.Event:

ophyd_async/core/_mock_signal_utils.py

@@ -2,17 +2,26 @@ from collections.abc import Awaitable, Callable, Iterable
 from contextlib import asynccontextmanager, contextmanager
 from unittest.mock import AsyncMock, Mock
 
-from ._device import Device, _device_mocks
+from ._device import Device
 from ._mock_signal_backend import MockSignalBackend
-from ._signal import Signal, SignalR, _mock_signal_backends
+from ._signal import Signal, SignalConnector, SignalR
 from ._soft_signal_backend import SignalDatatypeT
+from ._utils import LazyMock
+
+
+def get_mock(device: Device | Signal) -> Mock:
+    mock = device._mock  # noqa: SLF001
+    assert isinstance(mock, LazyMock), f"Device {device} not connected in mock mode"
+    return mock()
 
 
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:
-    assert (
-        signal in _mock_signal_backends
+    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"
-    return _mock_signal_backends[signal]
+    return connector.backend
 
 
 def set_mock_value(signal: Signal[SignalDatatypeT], value: SignalDatatypeT):
@@ -45,12 +54,6 @@ def get_mock_put(signal: Signal) -> AsyncMock:
     return _get_mock_signal_backend(signal).put_mock
 
 
-def get_mock(device: Device | Signal) -> Mock:
-    if isinstance(device, Signal):
-        return _get_mock_signal_backend(device).mock
-    return _device_mocks[device]
-
-
 def reset_mock_put_calls(signal: Signal):
     backend = _get_mock_signal_backend(signal)
     backend.put_mock.reset_mock()

ophyd_async/core/_readable.py

@@ -1,6 +1,8 @@
 import warnings
-from collections.abc import Callable, Generator, Sequence
+from collections.abc import Awaitable, Callable, Generator, Sequence
 from contextlib import contextmanager
+from enum import Enum
+from typing import Any, cast
 
 from bluesky.protocols import HasHints, Hints, Reading
 from event_model import DataKey
@@ -11,11 +13,61 @@ from ._signal import SignalR
 from ._status import AsyncStatus
 from ._utils import merge_gathered_dicts
 
-ReadableChild = AsyncReadable | AsyncConfigurable | AsyncStageable | HasHints
-ReadableChildWrapper = (
-    Callable[[ReadableChild], ReadableChild]
-    | type["ConfigSignal"]
-    | type["HintedSignal"]
+
+class StandardReadableFormat(Enum):
+    """Declare how a `Device` should contribute to the `StandardReadable` verbs."""
+
+    #: Detect which verbs the child supports and contribute to:
+    #:
+    #: - ``read()``, ``describe()`` if it is `bluesky.protocols.Readable`
+    #: - ``read_configuration()``, ``describe_configuration()`` if it is
+    #:   `bluesky.protocols.Configurable`
+    #: - ``stage()``, ``unstage()`` if it is `bluesky.protocols.Stageable`
+    #: - ``hints`` if it `bluesky.protocols.HasHints`
+    CHILD = "CHILD"
+    #: Contribute the `Signal` value to ``read_configuration()`` and
+    #: ``describe_configuration()``
+    CONFIG_SIGNAL = "CONFIG_SIGNAL"
+    #: Contribute the monitored `Signal` value to ``read()`` and ``describe()``` and
+    #: put the signal name in ``hints``
+    HINTED_SIGNAL = "HINTED_SIGNAL"
+    #: Contribute the uncached `Signal` value to ``read()`` and ``describe()```
+    UNCACHED_SIGNAL = "UNCACHED_SIGNAL"
+    #: Contribute the uncached `Signal` value to ``read()`` and ``describe()``` and
+    #: put the signal name in ``hints``
+    HINTED_UNCACHED_SIGNAL = "HINTED_UNCACHED_SIGNAL"
+
+    def __call__(self, parent: Device, child: Device):
+        if not isinstance(parent, StandardReadable):
+            raise TypeError(f"Expected parent to be StandardReadable, got {parent}")
+        parent.add_readables([child], self)
+
+
+# Back compat
+class _WarningMatcher:
+    def __init__(self, name: str, target: StandardReadableFormat):
+        self._name = name
+        self._target = target
+
+    def __eq__(self, value: object) -> bool:
+        warnings.warn(
+            DeprecationWarning(
+                f"Use `StandardReadableFormat.{self._target.name}` "
+                f"instead of `{self._name}`"
+            ),
+            stacklevel=2,
+        )
+        return value == self._target
+
+
+def _compat_format(name: str, target: StandardReadableFormat) -> StandardReadableFormat:
+    return cast(StandardReadableFormat, _WarningMatcher(name, target))
+
+
+ConfigSignal = _compat_format("ConfigSignal", StandardReadableFormat.CONFIG_SIGNAL)
+HintedSignal: Any = _compat_format("HintedSignal", StandardReadableFormat.HINTED_SIGNAL)
+HintedSignal.uncached = _compat_format(
+    "HintedSignal.uncached", StandardReadableFormat.HINTED_UNCACHED_SIGNAL
 )
 
 
@@ -31,38 +83,13 @@ class StandardReadable(
 
     # These must be immutable types to avoid accidental sharing between
     # different instances of the class
-    _readables: tuple[AsyncReadable, ...] = ()
-    _configurables: tuple[AsyncConfigurable, ...] = ()
+    _describe_config_funcs: tuple[Callable[[], Awaitable[dict[str, DataKey]]], ...] = ()
+    _read_config_funcs: tuple[Callable[[], Awaitable[dict[str, Reading]]], ...] = ()
+    _describe_funcs: tuple[Callable[[], Awaitable[dict[str, DataKey]]], ...] = ()
+    _read_funcs: tuple[Callable[[], Awaitable[dict[str, Reading]]], ...] = ()
     _stageables: tuple[AsyncStageable, ...] = ()
     _has_hints: tuple[HasHints, ...] = ()
 
-    def set_readable_signals(
-        self,
-        read: Sequence[SignalR] = (),
-        config: Sequence[SignalR] = (),
-        read_uncached: Sequence[SignalR] = (),
-    ):
-        """
-        Parameters
-        ----------
-        read:
-            Signals to make up :meth:`~StandardReadable.read`
-        conf:
-            Signals to make up :meth:`~StandardReadable.read_configuration`
-        read_uncached:
-            Signals to make up :meth:`~StandardReadable.read` that won't be cached
-        """
-        warnings.warn(
-            DeprecationWarning(
-                "Migrate to `add_children_as_readables` context manager or "
-                "`add_readables` method"
-            ),
-            stacklevel=2,
-        )
-        self.add_readables(read, wrapper=HintedSignal)
-        self.add_readables(config, wrapper=ConfigSignal)
-        self.add_readables(read_uncached, wrapper=HintedSignal.uncached)
-
     @AsyncStatus.wrap
     async def stage(self) -> None:
         for sig in self._stageables:
@@ -75,19 +102,17 @@ class StandardReadable(
 
     async def describe_configuration(self) -> dict[str, DataKey]:
         return await merge_gathered_dicts(
-            [sig.describe_configuration() for sig in self._configurables]
+            [func() for func in self._describe_config_funcs]
         )
 
     async def read_configuration(self) -> dict[str, Reading]:
-        return await merge_gathered_dicts(
-            [sig.read_configuration() for sig in self._configurables]
-        )
+        return await merge_gathered_dicts([func() for func in self._read_config_funcs])
 
     async def describe(self) -> dict[str, DataKey]:
-        return await merge_gathered_dicts([sig.describe() for sig in self._readables])
+        return await merge_gathered_dicts([func() for func in self._describe_funcs])
 
     async def read(self) -> dict[str, Reading]:
-        return await merge_gathered_dicts([sig.read() for sig in self._readables])
+        return await merge_gathered_dicts([func() for func in self._read_funcs])
 
     @property
     def hints(self) -> Hints:
@@ -127,27 +152,13 @@ class StandardReadable(
     @contextmanager
     def add_children_as_readables(
         self,
-        wrapper: ReadableChildWrapper | None = None,
+        format: StandardReadableFormat = StandardReadableFormat.CHILD,
     ) -> Generator[None, None, None]:
-        """Context manager to wrap adding Devices
+        """Context manager that calls `add_readables` on child Devices added within.
 
-        Add Devices to this class instance inside the Context Manager to automatically
-        add them to the correct fields, based on the Device's interfaces.
-
-        The provided wrapper class will be applied to all Devices and can be used to
-        specify their behaviour.
-
-        Parameters
-        ----------
-        wrapper:
-            Wrapper class to apply to all Devices created inside the context manager.
-
-        See Also
-        --------
-        :func:`~StandardReadable.add_readables`
-        :class:`ConfigSignal`
-        :class:`HintedSignal`
-        :meth:`HintedSignal.uncached`
+        Scans ``self.children()`` on entry and exit to context manager, and calls
+        `add_readables` on any that are added with the provided
+        `StandardReadableFormat`.
         """
 
         dict_copy = dict(self.children())
@@ -167,95 +178,83 @@ class StandardReadable(
                 flattened_values.append(value)
 
         new_devices = list(filter(lambda x: isinstance(x, Device), flattened_values))
-        self.add_readables(new_devices, wrapper)
+        self.add_readables(new_devices, format)
 
     def add_readables(
         self,
-        devices: Sequence[ReadableChild],
-        wrapper: ReadableChildWrapper | None = None,
+        devices: Sequence[Device],
+        format: StandardReadableFormat = StandardReadableFormat.CHILD,
     ) -> None:
-        """Add the given devices to the lists of known Devices
+        """Add devices to contribute to various bluesky verbs.
 
-        Add the provided Devices to the relevant fields, based on the Signal's
-        interfaces.
+        Use output from the given devices to contribute to the verbs of the following
+        interfaces:
 
-        The provided wrapper class will be applied to all Devices and can be used to
-        specify their behaviour.
+        - `bluesky.protocols.Readable`
+        - `bluesky.protocols.Configurable`
+        - `bluesky.protocols.Stageable`
+        - `bluesky.protocols.HasHints`
 
         Parameters
         ----------
         devices:
             The devices to be added
-        wrapper:
-            Wrapper class to apply to all Devices created inside the context manager.
-
-        See Also
-        --------
-        :func:`~StandardReadable.add_children_as_readables`
-        :class:`ConfigSignal`
-        :class:`HintedSignal`
-        :meth:`HintedSignal.uncached`
+        format:
+            Determines which of the devices functions are added to which verb as per the
+            `StandardReadableFormat` documentation
         """
 
-        for readable in devices:
-            obj = readable
-            if wrapper:
-                obj = wrapper(readable)
-
-            if isinstance(obj, AsyncReadable):
-                self._readables += (obj,)
-
-            if isinstance(obj, AsyncConfigurable):
-                self._configurables += (obj,)
-
-            if isinstance(obj, AsyncStageable):
-                self._stageables += (obj,)
-
-            if isinstance(obj, HasHints):
-                self._has_hints += (obj,)
-
-
-class ConfigSignal(AsyncConfigurable):
-    def __init__(self, signal: ReadableChild) -> None:
-        assert isinstance(signal, SignalR), f"Expected signal, got {signal}"
+        for device in devices:
+            match format:
+                case StandardReadableFormat.CHILD:
+                    if isinstance(device, AsyncConfigurable):
+                        self._describe_config_funcs += (device.describe_configuration,)
+                        self._read_config_funcs += (device.read_configuration,)
+                    if isinstance(device, AsyncReadable):
+                        self._describe_funcs += (device.describe,)
+                        self._read_funcs += (device.read,)
+                    if isinstance(device, AsyncStageable):
+                        self._stageables += (device,)
+                    if isinstance(device, HasHints):
+                        self._has_hints += (device,)
+                case StandardReadableFormat.CONFIG_SIGNAL:
+                    assert isinstance(device, SignalR), f"{device} is not a SignalR"
+                    self._describe_config_funcs += (device.describe,)
+                    self._read_config_funcs += (device.read,)
+                case StandardReadableFormat.HINTED_SIGNAL:
+                    assert isinstance(device, SignalR), f"{device} is not a SignalR"
+                    self._describe_funcs += (device.describe,)
+                    self._read_funcs += (device.read,)
+                    self._stageables += (device,)
+                    self._has_hints += (_HintsFromName(device),)
+                case StandardReadableFormat.UNCACHED_SIGNAL:
+                    assert isinstance(device, SignalR), f"{device} is not a SignalR"
+                    self._describe_funcs += (device.describe,)
+                    self._read_funcs += (_UncachedRead(device),)
+                case StandardReadableFormat.HINTED_UNCACHED_SIGNAL:
+                    assert isinstance(device, SignalR), f"{device} is not a SignalR"
+                    self._describe_funcs += (device.describe,)
+                    self._read_funcs += (_UncachedRead(device),)
+                    self._has_hints += (_HintsFromName(device),)
+
+
+class _UncachedRead:
+    def __init__(self, signal: SignalR) -> None:
         self.signal = signal
 
-    async def read_configuration(self) -> dict[str, Reading]:
-        return await self.signal.read()
-
-    async def describe_configuration(self) -> dict[str, DataKey]:
-        return await self.signal.describe()
-
-    @property
-    def name(self) -> str:
-        return self.signal.name
+    async def __call__(self) -> dict[str, Reading]:
+        return await self.signal.read(cached=False)
 
 
-class HintedSignal(HasHints, AsyncReadable):
-    def __init__(self, signal: ReadableChild, allow_cache: bool = True) -> None:
-        assert isinstance(signal, SignalR), f"Expected signal, got {signal}"
-        self.signal = signal
-        self.cached = None if allow_cache else allow_cache
-        if allow_cache:
-            self.stage = signal.stage
-            self.unstage = signal.unstage
-
-    async def read(self) -> dict[str, Reading]:
-        return await self.signal.read(cached=self.cached)
-
-    async def describe(self) -> dict[str, DataKey]:
-        return await self.signal.describe()
+class _HintsFromName(HasHints):
+    def __init__(self, device: Device) -> None:
+        self.device = device
 
     @property
     def name(self) -> str:
-        return self.signal.name
+        return self.device.name
 
     @property
     def hints(self) -> Hints:
-        if self.signal.name == "":
-            return {"fields": []}
-        return {"fields": [self.signal.name]}
-
-    @classmethod
-    def uncached(cls, signal: ReadableChild) -> "HintedSignal":
-        return cls(signal, allow_cache=False)
+        fields = [self.name] if self.name else []
+        return {"fields": fields}

ophyd_async/core/_signal.py

@@ -4,7 +4,6 @@ import asyncio
 import functools
 from collections.abc import AsyncGenerator, Awaitable, Callable, Mapping
 from typing import Any, Generic, cast
-from unittest.mock import Mock
 
 from bluesky.protocols import (
     Locatable,
@@ -30,9 +29,14 @@ from ._signal_backend import (
 )
 from ._soft_signal_backend import SoftSignalBackend
 from ._status import AsyncStatus
-from ._utils import CALCULATE_TIMEOUT, DEFAULT_TIMEOUT, CalculatableTimeout, Callback, T
-
-_mock_signal_backends: dict[Device, MockSignalBackend] = {}
+from ._utils import (
+    CALCULATE_TIMEOUT,
+    DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    Callback,
+    LazyMock,
+    T,
+)
 
 
 async def _wait_for(coro: Awaitable[T], timeout: float | None, source: str) -> T:
@@ -54,26 +58,28 @@ class SignalConnector(DeviceConnector):
     def __init__(self, backend: SignalBackend):
         self.backend = self._init_backend = backend
 
-    async def connect(
-        self,
-        device: Device,
-        mock: bool | Mock,
-        timeout: float,
-        force_reconnect: bool,
-    ):
-        if mock:
-            self.backend = MockSignalBackend(self._init_backend, mock)
-            _mock_signal_backends[device] = self.backend
-        else:
-            self.backend = self._init_backend
+    async def connect_mock(self, device: Device, mock: LazyMock):
+        self.backend = MockSignalBackend(self._init_backend, mock)
+
+    async def connect_real(self, device: Device, timeout: float, force_reconnect: bool):
+        self.backend = self._init_backend
         device.log.debug(f"Connecting to {self.backend.source(device.name, read=True)}")
         await self.backend.connect(timeout)
 
 
+class _ChildrenNotAllowed(dict[str, Device]):
+    def __setitem__(self, key: str, value: Device) -> None:
+        raise AttributeError(
+            f"Cannot add Device or Signal child {key}={value} of Signal, "
+            "make a subclass of Device instead"
+        )
+
+
 class Signal(Device, Generic[SignalDatatypeT]):
     """A Device with the concept of a value, with R, RW, W and X flavours"""
 
     _connector: SignalConnector
+    _child_devices = _ChildrenNotAllowed()  # type: ignore
 
     def __init__(
         self,
@@ -89,14 +95,6 @@ class Signal(Device, Generic[SignalDatatypeT]):
         """Like ca://PV_PREFIX:SIGNAL, or "" if not set"""
         return self._connector.backend.source(self.name, read=True)
 
-    def __setattr__(self, name: str, value: Any) -> None:
-        if name != "parent" and isinstance(value, Device):
-            raise AttributeError(
-                f"Cannot add Device or Signal {value} as a child of Signal {self}, "
-                "make a subclass of Device instead"
-            )
-        return super().__setattr__(name, value)
-
 
 class _SignalCache(Generic[SignalDatatypeT]):
     def __init__(self, backend: SignalBackend[SignalDatatypeT], signal: Signal):

ophyd_async/core/_soft_signal_backend.py

@@ -4,6 +4,7 @@ import time
 from abc import abstractmethod
 from collections.abc import Sequence
 from dataclasses import dataclass
+from functools import lru_cache
 from typing import Any, Generic, get_origin
 
 import numpy as np
@@ -90,6 +91,7 @@ class TableSoftConverter(SoftConverter[TableT]):
             raise TypeError(f"Cannot convert {value} to {self.datatype}")
 
 
+@lru_cache
 def make_converter(datatype: type[SignalDatatype]) -> SoftConverter:
     enum_cls = get_enum_cls(datatype)
     if datatype == Sequence[str]:

ophyd_async/core/_utils.py

@@ -5,7 +5,16 @@ import logging
 from collections.abc import Awaitable, Callable, Iterable, Sequence
 from dataclasses import dataclass
 from enum import Enum, EnumMeta
-from typing import Any, Generic, Literal, ParamSpec, TypeVar, get_args, get_origin
+from typing import (
+    Any,
+    Generic,
+    Literal,
+    ParamSpec,
+    TypeVar,
+    get_args,
+    get_origin,
+)
+from unittest.mock import Mock
 
 import numpy as np
 
@@ -112,20 +121,29 @@ async def wait_for_connection(**coros: Awaitable[None]):
 
     Expected kwargs should be a mapping of names to coroutine tasks to execute.
     """
-    results = await asyncio.gather(*coros.values(), return_exceptions=True)
-    exceptions = {}
+    exceptions: dict[str, Exception] = {}
+    if len(coros) == 1:
+        # Single device optimization
+        name, coro = coros.popitem()
+        try:
+            await coro
+        except Exception as e:
+            exceptions[name] = e
+    else:
+        # Use gather to connect in parallel
+        results = await asyncio.gather(*coros.values(), return_exceptions=True)
+        for name, result in zip(coros, results, strict=False):
+            if isinstance(result, Exception):
+                exceptions[name] = result
 
-    for name, result in zip(coros, results, strict=False):
-        if isinstance(result, Exception):
-            exceptions[name] = result
-            if not isinstance(result, NotConnected):
+    if exceptions:
+        for name, exception in exceptions.items():
+            if not isinstance(exception, NotConnected):
                 logging.exception(
                     f"device `{name}` raised unexpected exception "
-                    f"{type(result).__name__}",
-                    exc_info=result,
+                    f"{type(exception).__name__}",
+                    exc_info=exception,
                 )
-
-    if exceptions:
         raise NotConnected(exceptions)
 
 
@@ -244,3 +262,38 @@ class Reference(Generic[T]):
 
     def __call__(self) -> 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.
+
+    >>> 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 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

ophyd_async/epics/adaravis/_aravis_io.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StrictEnum, SubsetEnum
 from ophyd_async.epics import adcore
-from ophyd_async.epics.signal import epics_signal_rw_rbv
+from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class AravisTriggerMode(StrictEnum):

ophyd_async/epics/adcore/_core_io.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import Device, StrictEnum
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,

ophyd_async/epics/adcore/_single_trigger.py

@@ -3,13 +3,8 @@ from collections.abc import Sequence
 
 from bluesky.protocols import Triggerable
 
-from ophyd_async.core import (
-    AsyncStatus,
-    ConfigSignal,
-    HintedSignal,
-    SignalR,
-    StandardReadable,
-)
+from ophyd_async.core import AsyncStatus, SignalR, StandardReadable
+from ophyd_async.core import StandardReadableFormat as Format
 
 from ._core_io import ADBaseIO, NDPluginBaseIO
 from ._utils import ImageMode
@@ -24,14 +19,15 @@ class SingleTriggerDetector(StandardReadable, Triggerable):
         **plugins: NDPluginBaseIO,
     ) -> None:
         self.drv = drv
-        self.__dict__.update(plugins)
+        for k, v in plugins.items():
+            setattr(self, k, v)
 
         self.add_readables(
             [self.drv.array_counter, *read_uncached],
-            wrapper=HintedSignal.uncached,
+            Format.HINTED_UNCACHED_SIGNAL,
         )
 
-        self.add_readables([self.drv.acquire_time], wrapper=ConfigSignal)
+        self.add_readables([self.drv.acquire_time], Format.CONFIG_SIGNAL)
 
         super().__init__(name=name)