ophyd-async 0.9.0a2__py3-none-any.whl → 0.10.0a2__py3-none-any.whl

ophyd_async/core/_utils.py

@@ -11,10 +11,10 @@ from unittest.mock import Mock
 import numpy as np
 
 T = TypeVar("T")
+V = TypeVar("V")
 P = ParamSpec("P")
 Callback = Callable[[T], None]
 DEFAULT_TIMEOUT = 10.0
-ErrorText = str | Mapping[str, Exception]
 
 logger = logging.getLogger("ophyd_async")
 
@@ -29,18 +29,33 @@ class StrictEnumMeta(EnumMeta):
 
 
 class StrictEnum(str, Enum, metaclass=StrictEnumMeta):
-    """All members should exist in the Backend, and there will be no extras"""
+    """All members should exist in the Backend, and there will be no extras."""
 
 
 class SubsetEnumMeta(StrictEnumMeta):
     def __call__(self, value, *args, **kwargs):  # type: ignore
+        """Return given value if it is a string and not a member of the enum.
+
+        If the value is not a string or is an enum member, default enum behavior
+        is applied. Type checking will complain if provided arbitrary string.
+
+        Returns:
+            Union[str, SubsetEnum]: If the value is a string and not a member of the
+            enum, the string is returned as is. Otherwise, the corresponding enum
+            member is returned.
+
+        Raises:
+            ValueError: If the value is not a string and cannot be converted to an enum
+            member.
+
+        """
         if isinstance(value, str) and not isinstance(value, self):
             return value
         return super().__call__(value, *args, **kwargs)
 
 
 class SubsetEnum(StrictEnum, metaclass=SubsetEnumMeta):
-    """All members should exist in the Backend, but there may be extras"""
+    """All members should exist in the Backend, but there may be extras."""
 
 
 CALCULATE_TIMEOUT = "CALCULATE_TIMEOUT"
@@ -55,22 +70,16 @@ CalculatableTimeout = float | None | Literal["CALCULATE_TIMEOUT"]
 
 
 class NotConnected(Exception):
-    """Exception to be raised if a `Device.connect` is cancelled"""
+    """Exception to be raised if a `Device.connect` is cancelled.
 
-    _indent_width = "    "
+    :param errors:
+        Mapping of device name to Exception or another NotConnected.
+        Alternatively a string with the signal error text.
+    """
 
-    def __init__(self, errors: ErrorText):
-        """
-        NotConnected holds a mapping of device/signal names to
-        errors.
-
-        Parameters
-        ----------
-        errors: ErrorText
-            Mapping of device name to Exception or another NotConnected.
-            Alternatively a string with the signal error text.
-        """
+    _indent_width = "    "
 
+    def __init__(self, errors: str | Mapping[str, Exception]):
         self._errors = errors
 
     @property
@@ -126,21 +135,38 @@ class NotConnected(Exception):
 
 @dataclass(frozen=True)
 class WatcherUpdate(Generic[T]):
-    """A dataclass such that, when expanded, it provides the kwargs for a watcher"""
+    """A dataclass such that, when expanded, it provides the kwargs for a watcher."""
 
     current: T
+    """The current value, where it currently is."""
+
     initial: T
+    """The initial value, where it was when it started."""
+
     target: T
+    """The target value, where it will be when it finishes."""
+
     name: str | None = None
+    """An optional name for the device, if available."""
+
     unit: str | None = None
+    """Units of the value, if applicable."""
+
     precision: float | None = None
+    """How many decimal places the value should be displayed to."""
+
     fraction: float | None = None
+    """The fraction of the way between initial and target."""
+
     time_elapsed: float | None = None
+    """The time elapsed since the start of the operation."""
+
     time_remaining: float | None = None
+    """The time remaining until the operation completes."""
 
 
 async def wait_for_connection(**coros: Awaitable[None]):
-    """Call many underlying signals, accumulating exceptions and returning them
+    """Call many underlying signals, accumulating exceptions and returning them.
 
     Expected kwargs should be a mapping of names to coroutine tasks to execute.
     """
@@ -164,12 +190,15 @@ async def wait_for_connection(**coros: Awaitable[None]):
 
 
 def get_dtype(datatype: type) -> np.dtype:
-    """Get the runtime dtype from a numpy ndarray type annotation
+    """Get the runtime dtype from a numpy ndarray type annotation.
 
+    ```python
     >>> from ophyd_async.core import Array1D
     >>> import numpy as np
     >>> get_dtype(Array1D[np.int8])
     dtype('int8')
+
+    ```
     """
     if not get_origin(datatype) == np.ndarray:
         raise TypeError(f"Expected Array1D[dtype], got {datatype}")
@@ -179,12 +208,21 @@ def get_dtype(datatype: type) -> np.dtype:
 
 
 def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
-    """Get the runtime dtype from a numpy ndarray type annotation
-
-    >>> import numpy.typing as npt
-    >>> import numpy as np
-    >>> get_dtype(npt.NDArray[np.int8])
-    dtype('int8')
+    """Get the enum class from a datatype.
+
+    :raises TypeError: if type is not a [](#StrictEnum) or [](#SubsetEnum) subclass
+    ```python
+    >>> from ophyd_async.core import StrictEnum
+    >>> from collections.abc import Sequence
+    >>> class MyEnum(StrictEnum):
+    ...     A = "A value"
+    >>> get_enum_cls(str)
+    >>> get_enum_cls(MyEnum)
+    <enum 'MyEnum'>
+    >>> get_enum_cls(Sequence[MyEnum])
+    <enum 'MyEnum'>
+
+    ```
     """
     if get_origin(datatype) is Sequence:
         datatype = get_args(datatype)[0]
@@ -195,17 +233,21 @@ def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
                 "or ophyd_async.core.StrictEnum"
             )
         return datatype
+    return None
 
 
 def get_unique(values: dict[str, T], types: str) -> T:
-    """If all values are the same, return that value, otherwise raise TypeError
+    """If all values are the same, return that value, otherwise raise TypeError.
 
+    ```python
     >>> get_unique({"a": 1, "b": 1}, "integers")
     1
     >>> get_unique({"a": 1, "b": 2}, "integers")
     Traceback (most recent call last):
      ...
     TypeError: Differing integers: a has 1, b has 2
+
+    ```
     """
     set_values = set(values.values())
     if len(set_values) != 1:
@@ -219,9 +261,12 @@ async def merge_gathered_dicts(
 ) -> dict[str, T]:
     """Merge dictionaries produced by a sequence of coroutines.
 
-    Can be used for merging ``read()`` or ``describe``. For instance::
+    Can be used for merging `read()` or `describe()`.
 
-        combined_read = await merge_gathered_dicts(s.read() for s in signals)
+    :example:
+    ```python
+    combined_read = await merge_gathered_dicts(s.read() for s in signals)
+    ```
     """
     ret: dict[str, T] = {}
     for result in await asyncio.gather(*coros):
@@ -229,21 +274,18 @@ async def merge_gathered_dicts(
     return ret
 
 
-async def gather_list(coros: Iterable[Awaitable[T]]) -> list[T]:
-    return await asyncio.gather(*coros)
+async def gather_dict(coros: Mapping[T, Awaitable[V]]) -> dict[T, V]:
+    """Take named coros and return a dict of their name to their return value."""
+    values = await asyncio.gather(*coros.values())
+    return dict(zip(coros, values, strict=True))
 
 
 def in_micros(t: float) -> int:
-    """
-    Converts between a positive number of seconds and an equivalent
-    number of microseconds.
-
-    Args:
-        t (float): A time in seconds
-    Raises:
-        ValueError: if t < 0
-    Returns:
-        t (int): A time in microseconds, rounded up to the nearest whole microsecond,
+    """Convert between a seconds and microseconds.
+
+    :param t: A time in seconds
+    :return: A time in microseconds, rounded up to the nearest whole microsecond
+    :raises ValueError: if t < 0
     """
     if t < 0:
         raise ValueError(f"Expected a positive time in seconds, got {t!r}")
@@ -254,6 +296,7 @@ def get_origin_class(annotatation: Any) -> type | None:
     origin = get_origin(annotatation) or annotatation
     if isinstance(origin, type):
         return origin
+    return None
 
 
 class Reference(Generic[T]):
@@ -261,16 +304,16 @@ class Reference(Generic[T]):
 
     Used to opt out of the naming/parent-child relationship of `Device`.
 
-    For example::
-
-        class DeviceWithRefToSignal(Device):
-            def __init__(self, signal: SignalRW[int]):
-                self.signal_ref = Reference(signal)
-                super().__init__()
-
-            def set(self, value) -> AsyncStatus:
-                return self.signal_ref().set(value + 1)
+    :example:
+    ```python
+    class DeviceWithRefToSignal(Device):
+        def __init__(self, signal: SignalRW[int]):
+            self.signal_ref = Reference(signal)
+            super().__init__()
 
+        def set(self, value) -> AsyncStatus:
+            return self.signal_ref().set(value + 1)
+    ```
     """
 
     def __init__(self, obj: T):
@@ -289,6 +332,7 @@ class LazyMock:
     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()
@@ -297,6 +341,8 @@ class LazyMock:
     >>> parent_mock = parent()
     >>> parent_mock.mock_calls
     [call.child()]
+
+    ```
     """
 
     def __init__(self, name: str = "", parent: LazyMock | None = None) -> None:
@@ -305,6 +351,7 @@ class LazyMock:
         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:

ophyd_async/core/_yaml_settings.py

@@ -28,6 +28,8 @@ def enum_representer(dumper: yaml.Dumper, enum: Enum) -> yaml.Node:
 
 
 class YamlSettingsProvider(SettingsProvider):
+    """For providing settings from yaml to signals."""
+
     def __init__(self, directory: Path | str):
         self._directory = Path(directory)
 

ophyd_async/epics/__init__.py

@@ -0,0 +1 @@
+"""EPICS support for Signals, and Devices that use them."""

ophyd_async/epics/adandor/_andor.py

@@ -9,8 +9,8 @@ from ._andor_io import Andor2DriverIO
 
 
 class Andor2Detector(adcore.AreaDetector[Andor2Controller]):
-    """
-    Andor 2 area detector device (CCD detector 56fps with full chip readout).
+    """Andor 2 area detector device (CCD detector 56fps with full chip readout).
+
     Andor model:DU897_BV.
     """
 

ophyd_async/epics/adandor/_andor_controller.py

@@ -13,10 +13,12 @@ _MAX_NUM_IMAGE = 999_999
 
 
 class Andor2Controller(adcore.ADBaseController[Andor2DriverIO]):
+    """For controlling the Andor 2 detector."""
+
     def __init__(
         self,
         driver: Andor2DriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
         super().__init__(driver, good_states=good_states)
 
@@ -32,7 +34,7 @@ class Andor2Controller(adcore.ADBaseController[Andor2DriverIO]):
             self.driver.num_images.set(
                 trigger_info.total_number_of_triggers or _MAX_NUM_IMAGE
             ),
-            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
+            self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
 
     def _get_trigger_mode(self, trigger: DetectorTrigger) -> Andor2TriggerMode:

ophyd_async/epics/adandor/_andor_io.py

@@ -23,14 +23,12 @@ class Andor2DataType(SubsetEnum):
 
 
 class Andor2DriverIO(ADBaseIO):
-    """
-    Epics pv for andor model:DU897_BV as deployed on p99
-    """
+    """Epics pv for andor model:DU897_BV as deployed on p99."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
         super().__init__(prefix, name=name)
         self.trigger_mode = epics_signal_rw(Andor2TriggerMode, prefix + "TriggerMode")
-        self.data_type = epics_signal_r(Andor2DataType, prefix + "DataType_RBV")
+        self.data_type = epics_signal_r(Andor2DataType, prefix + "DataType_RBV")  # type: ignore
         self.andor_accumulate_period = epics_signal_r(
             float, prefix + "AndorAccumulatePeriod_RBV"
         )

ophyd_async/epics/adaravis/__init__.py

@@ -1,3 +1,8 @@
+"""Support for the ADAravis areaDetector driver.
+
+https://github.com/areaDetector/ADAravis
+"""
+
 from ._aravis import AravisDetector
 from ._aravis_controller import AravisController
 from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource

ophyd_async/epics/adaravis/_aravis.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core._signal import SignalR
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._aravis_controller import AravisController
@@ -9,8 +8,8 @@ from ._aravis_io import AravisDriverIO
 
 
 class AravisDetector(adcore.AreaDetector[AravisController]):
-    """
-    Ophyd-async implementation of an ADAravis Detector.
+    """Implementation of an ADAravis Detector.
+
     The detector may be configured for an external trigger on a GPIO port,
     which must be done prior to preparing the detector
     """
@@ -23,13 +22,11 @@ class AravisDetector(adcore.AreaDetector[AravisController]):
         writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
         fileio_suffix: str | None = None,
         name: str = "",
-        gpio_number: AravisController.GPIO_NUMBER = 1,
         config_sigs: Sequence[SignalR] = (),
         plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
     ):
         driver = AravisDriverIO(prefix + drv_suffix)
-        controller = AravisController(driver, gpio_number=gpio_number)
-
+        controller = AravisController(driver)
         writer = writer_cls.with_io(
             prefix,
             path_provider,
@@ -37,7 +34,6 @@ class AravisDetector(adcore.AreaDetector[AravisController]):
             fileio_suffix=fileio_suffix,
             plugins=plugins,
         )
-
         super().__init__(
             controller=controller,
             writer=writer,

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -1,10 +1,6 @@
 import asyncio
-from typing import Literal
 
-from ophyd_async.core import (
-    DetectorTrigger,
-    TriggerInfo,
-)
+from ophyd_async.core import DetectorTrigger, TriggerInfo
 from ophyd_async.epics import adcore
 
 from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
@@ -16,53 +12,34 @@ _HIGHEST_POSSIBLE_DEADTIME = 1961e-6
 
 
 class AravisController(adcore.ADBaseController[AravisDriverIO]):
-    GPIO_NUMBER = Literal[1, 2, 3, 4]
-
-    def __init__(
-        self,
-        driver: AravisDriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
-        gpio_number: GPIO_NUMBER = 1,
-    ) -> None:
-        super().__init__(driver, good_states=good_states)
-        self.gpio_number = gpio_number
+    """`DetectorController` for an `AravisDriverIO`."""
 
     def get_deadtime(self, exposure: float | None) -> float:
         return _HIGHEST_POSSIBLE_DEADTIME
 
-    async def prepare(self, trigger_info: TriggerInfo):
-        if trigger_info.total_number_of_triggers == 0:
-            image_mode = adcore.ImageMode.CONTINUOUS
-        else:
-            image_mode = adcore.ImageMode.MULTIPLE
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
         if (exposure := trigger_info.livetime) is not None:
             await self.driver.acquire_time.set(exposure)
 
-        trigger_mode, trigger_source = self._get_trigger_info(trigger_info.trigger)
-        # trigger mode must be set first and on it's own!
-        await self.driver.trigger_mode.set(trigger_mode)
+        if trigger_info.trigger is DetectorTrigger.INTERNAL:
+            # Set trigger mode off to ignore the trigger source
+            await self.driver.trigger_mode.set(AravisTriggerMode.OFF)
+        elif trigger_info.trigger in {
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.EDGE_TRIGGER,
+        }:
+            # Trigger on the rising edge of Line1
+            # trigger mode must be set first and on it's own!
+            await self.driver.trigger_mode.set(AravisTriggerMode.ON)
+            await self.driver.trigger_source.set(AravisTriggerSource.LINE1)
+        else:
+            raise ValueError(f"ADAravis does not support {trigger_info.trigger}")
 
+        if trigger_info.total_number_of_triggers == 0:
+            image_mode = adcore.ADImageMode.CONTINUOUS
+        else:
+            image_mode = adcore.ADImageMode.MULTIPLE
         await asyncio.gather(
-            self.driver.trigger_source.set(trigger_source),
             self.driver.num_images.set(trigger_info.total_number_of_triggers),
             self.driver.image_mode.set(image_mode),
         )
-
-    def _get_trigger_info(
-        self, trigger: DetectorTrigger
-    ) -> tuple[AravisTriggerMode, AravisTriggerSource]:
-        supported_trigger_types = (
-            DetectorTrigger.CONSTANT_GATE,
-            DetectorTrigger.EDGE_TRIGGER,
-            DetectorTrigger.INTERNAL,
-        )
-        if trigger not in supported_trigger_types:
-            raise ValueError(
-                f"{self.__class__.__name__} only supports the following trigger "
-                f"types: {supported_trigger_types} but was asked to "
-                f"use {trigger}"
-            )
-        if trigger == DetectorTrigger.INTERNAL:
-            return AravisTriggerMode.OFF, AravisTriggerSource.FREERUN
-        else:
-            return (AravisTriggerMode.ON, f"Line{self.gpio_number}")  # type: ignore

ophyd_async/epics/adaravis/_aravis_io.py

@@ -1,46 +1,31 @@
-from ophyd_async.core import StrictEnum, SubsetEnum
+from typing import Annotated as A
+
+from ophyd_async.core import SignalRW, StrictEnum, SubsetEnum
 from ophyd_async.epics import adcore
-from ophyd_async.epics.core import epics_signal_rw_rbv
+from ophyd_async.epics.core import PvSuffix
 
 
 class AravisTriggerMode(StrictEnum):
-    """GigEVision GenICAM standard: on=externally triggered"""
+    """GigEVision GenICAM standard TriggerMode."""
 
     ON = "On"
-    OFF = "Off"
+    """Use TriggerSource to trigger each frame"""
 
-
-"""A minimal set of TriggerSources that must be supported by the underlying record.
-    To enable hardware triggered scanning, line_N must support each N in GPIO_NUMBER.
-    To enable software triggered scanning, freerun must be supported.
-    Other enumerated values may or may not be preset.
-    To prevent requiring one Enum class per possible configuration, we set as this Enum
-    but read from the underlying signal as a str.
-    """
+    OFF = "Off"
+    """Just trigger as fast as you can"""
 
 
 class AravisTriggerSource(SubsetEnum):
-    FREERUN = "Freerun"
+    """Which trigger source to use when TriggerMode=On."""
+
     LINE1 = "Line1"
 
 
 class AravisDriverIO(adcore.ADBaseIO):
-    # If instantiating a new instance, ensure it is supported in the _deadtimes dict
-    """Generic Driver supporting the Manta and Mako drivers.
-    Fetches deadtime prior to use in a Streaming scan.
-
-    Requires driver firmware up to date:
-    - Model_RBV must be of the form "^(Mako|Manta) (model)$"
+    """Generic Driver supporting all GiGE cameras.
 
     This mirrors the interface provided by ADAravis/db/aravisCamera.template.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.trigger_mode = epics_signal_rw_rbv(
-            AravisTriggerMode, prefix + "TriggerMode"
-        )
-        self.trigger_source = epics_signal_rw_rbv(
-            AravisTriggerSource,  # type: ignore
-            prefix + "TriggerSource",
-        )
-        super().__init__(prefix, name=name)
+    trigger_mode: A[SignalRW[AravisTriggerMode], PvSuffix.rbv("TriggerMode")]
+    trigger_source: A[SignalRW[AravisTriggerSource], PvSuffix.rbv("TriggerSource")]

ophyd_async/epics/adcore/__init__.py

@@ -1,15 +1,24 @@
-from ._core_detector import AreaDetector
+"""Core components of the areaDetector software.
+
+https://github.com/areaDetector/ADCore
+"""
+
+from ._core_detector import AreaDetector, ContAcqAreaDetector
 from ._core_io import (
     ADBaseDatasetDescriber,
     ADBaseIO,
-    DetectorState,
+    ADCallbacks,
+    ADCompression,
+    ADState,
     NDArrayBaseIO,
+    NDCBFlushOnSoftTrgMode,
     NDFileHDFIO,
     NDFileIO,
     NDPluginBaseIO,
+    NDPluginCBIO,
     NDPluginStatsIO,
 )
-from ._core_logic import DEFAULT_GOOD_STATES, ADBaseController
+from ._core_logic import DEFAULT_GOOD_STATES, ADBaseContAcqController, ADBaseController
 from ._core_writer import ADWriter
 from ._hdf_writer import ADHDFWriter
 from ._jpeg_writer import ADJPEGWriter
@@ -17,8 +26,8 @@ from ._single_trigger import SingleTriggerDetector
 from ._tiff_writer import ADTIFFWriter
 from ._utils import (
     ADBaseDataType,
-    FileWriteMode,
-    ImageMode,
+    ADFileWriteMode,
+    ADImageMode,
     NDAttributeDataType,
     NDAttributeParam,
     NDAttributePv,
@@ -28,8 +37,12 @@ from ._utils import (
 
 __all__ = [
     "ADBaseIO",
+    "ADCallbacks",
+    "ADCompression",
+    "ADBaseContAcqController",
     "AreaDetector",
-    "DetectorState",
+    "ADState",
+    "ContAcqAreaDetector",
     "NDArrayBaseIO",
     "NDFileIO",
     "NDFileHDFIO",
@@ -44,11 +57,13 @@ __all__ = [
     "ADJPEGWriter",
     "SingleTriggerDetector",
     "ADBaseDataType",
-    "FileWriteMode",
-    "ImageMode",
+    "ADFileWriteMode",
+    "ADImageMode",
     "NDAttributePv",
     "NDAttributeParam",
     "NDAttributeDataType",
     "stop_busy_record",
     "NDAttributePvDbrType",
+    "NDCBFlushOnSoftTrgMode",
+    "NDPluginCBIO",
 ]

ophyd_async/epics/adcore/_core_detector.py

@@ -1,10 +1,12 @@
 from collections.abc import Sequence
 
 from ophyd_async.core import SignalR, StandardDetector
+from ophyd_async.core._providers import PathProvider
 
-from ._core_io import NDPluginBaseIO
-from ._core_logic import ADBaseControllerT
+from ._core_io import ADBaseIO, NDPluginBaseIO, NDPluginCBIO
+from ._core_logic import ADBaseContAcqController, ADBaseControllerT
 from ._core_writer import ADWriter
+from ._hdf_writer import ADHDFWriter
 
 
 class AreaDetector(StandardDetector[ADBaseControllerT, ADWriter]):
@@ -39,3 +41,41 @@ class AreaDetector(StandardDetector[ADBaseControllerT, ADWriter]):
                 f"Expected {self.name}.{name} to be a {plugin_type}, got {plugin}"
             )
         return plugin
+
+
+class ContAcqAreaDetector(AreaDetector[ADBaseContAcqController]):
+    """Ophyd-async implementation of a continuously acquiring AreaDetector."""
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_cls: type[ADBaseIO] = ADBaseIO,
+        drv_suffix: str = "cam1:",
+        cb_suffix: str = "CB1:",
+        writer_cls: type[ADWriter] = ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
+    ):
+        self.cb_plugin = NDPluginCBIO(prefix + cb_suffix)
+        driver = drv_cls(prefix + drv_suffix)
+        controller = ADBaseContAcqController(driver, self.cb_plugin)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            # Since the CB plugin controls acq, use it when checking shape
+            dataset_source=self.cb_plugin,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
+
+        super().__init__(
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
+            name=name,
+            config_sigs=config_sigs,
+        )