ophyd-async 0.8.0a6__py3-none-any.whl → 0.9.0__py3-none-any.whl

ophyd_async/epics/adcore/_utils.py

@@ -6,47 +6,48 @@ from ophyd_async.core import (
     SignalR,
     SignalRW,
     StrictEnum,
+    SubsetEnum,
     wait_for_value,
 )
 
 
 class ADBaseDataType(StrictEnum):
-    Int8 = "Int8"
-    UInt8 = "UInt8"
-    Int16 = "Int16"
-    UInt16 = "UInt16"
-    Int32 = "Int32"
-    UInt32 = "UInt32"
-    Int64 = "Int64"
-    UInt64 = "UInt64"
-    Float32 = "Float32"
-    Float64 = "Float64"
+    INT8 = "Int8"
+    UINT8 = "UInt8"
+    INT16 = "Int16"
+    UINT16 = "UInt16"
+    INT32 = "Int32"
+    UINT32 = "UInt32"
+    INT64 = "Int64"
+    UINT64 = "UInt64"
+    FLOAT32 = "Float32"
+    FLOAT64 = "Float64"
 
 
 def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
     ad_dtype_to_np_dtype = {
-        ADBaseDataType.Int8: "|i1",
-        ADBaseDataType.UInt8: "|u1",
-        ADBaseDataType.Int16: "<i2",
-        ADBaseDataType.UInt16: "<u2",
-        ADBaseDataType.Int32: "<i4",
-        ADBaseDataType.UInt32: "<u4",
-        ADBaseDataType.Int64: "<i8",
-        ADBaseDataType.UInt64: "<u8",
-        ADBaseDataType.Float32: "<f4",
-        ADBaseDataType.Float64: "<f8",
+        ADBaseDataType.INT8: "|i1",
+        ADBaseDataType.UINT8: "|u1",
+        ADBaseDataType.INT16: "<i2",
+        ADBaseDataType.UINT16: "<u2",
+        ADBaseDataType.INT32: "<i4",
+        ADBaseDataType.UINT32: "<u4",
+        ADBaseDataType.INT64: "<i8",
+        ADBaseDataType.UINT64: "<u8",
+        ADBaseDataType.FLOAT32: "<f4",
+        ADBaseDataType.FLOAT64: "<f8",
     }
     return ad_dtype_to_np_dtype[ad_dtype]
 
 
 def convert_pv_dtype_to_np(datatype: str) -> str:
     _pvattribute_to_ad_datatype = {
-        "DBR_SHORT": ADBaseDataType.Int16,
-        "DBR_ENUM": ADBaseDataType.Int16,
-        "DBR_INT": ADBaseDataType.Int32,
-        "DBR_LONG": ADBaseDataType.Int32,
-        "DBR_FLOAT": ADBaseDataType.Float32,
-        "DBR_DOUBLE": ADBaseDataType.Float64,
+        "DBR_SHORT": ADBaseDataType.INT16,
+        "DBR_ENUM": ADBaseDataType.INT16,
+        "DBR_INT": ADBaseDataType.INT32,
+        "DBR_LONG": ADBaseDataType.INT32,
+        "DBR_FLOAT": ADBaseDataType.FLOAT32,
+        "DBR_DOUBLE": ADBaseDataType.FLOAT64,
     }
     if datatype in ["DBR_STRING", "DBR_CHAR"]:
         np_datatype = "s40"
@@ -62,9 +63,9 @@ def convert_pv_dtype_to_np(datatype: str) -> str:
 
 def convert_param_dtype_to_np(datatype: str) -> str:
     _paramattribute_to_ad_datatype = {
-        "INT": ADBaseDataType.Int32,
-        "INT64": ADBaseDataType.Int64,
-        "DOUBLE": ADBaseDataType.Float64,
+        "INT": ADBaseDataType.INT32,
+        "INT64": ADBaseDataType.INT64,
+        "DOUBLE": ADBaseDataType.FLOAT64,
     }
     if datatype in ["STRING"]:
         np_datatype = "s40"
@@ -79,15 +80,15 @@ def convert_param_dtype_to_np(datatype: str) -> str:
 
 
 class FileWriteMode(StrictEnum):
-    single = "Single"
-    capture = "Capture"
-    stream = "Stream"
+    SINGLE = "Single"
+    CAPTURE = "Capture"
+    STREAM = "Stream"
 
 
-class ImageMode(StrictEnum):
-    single = "Single"
-    multiple = "Multiple"
-    continuous = "Continuous"
+class ImageMode(SubsetEnum):
+    SINGLE = "Single"
+    MULTIPLE = "Multiple"
+    CONTINUOUS = "Continuous"
 
 
 class NDAttributeDataType(StrictEnum):

ophyd_async/epics/adkinetix/_kinetix.py

@@ -1,44 +1,49 @@
-from bluesky.protocols import HasHints, Hints
+from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, StandardDetector
-from ophyd_async.epics import adcore
+from ophyd_async.core import PathProvider, SignalR
+from ophyd_async.epics.adcore import (
+    ADHDFWriter,
+    ADWriter,
+    AreaDetector,
+    NDPluginBaseIO,
+)
 
 from ._kinetix_controller import KinetixController
 from ._kinetix_io import KinetixDriverIO
 
 
-class KinetixDetector(StandardDetector, HasHints):
+class KinetixDetector(AreaDetector[KinetixController]):
     """
     Ophyd-async implementation of an ADKinetix Detector.
     https://github.com/NSLS-II/ADKinetix
     """
 
-    _controller: KinetixController
-    _writer: adcore.ADHDFWriter
-
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        drv_suffix: str = "cam1:",
+        writer_cls: type[ADWriter] = ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = KinetixDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = KinetixDriverIO(prefix + drv_suffix)
+        controller = KinetixController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            KinetixController(self.drv),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_time,),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )
-
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints

ophyd_async/epics/adkinetix/_kinetix_controller.py

@@ -1,8 +1,6 @@
 import asyncio
 
 from ophyd_async.core import (
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
 )
@@ -11,44 +9,34 @@ from ophyd_async.epics import adcore
 from ._kinetix_io import KinetixDriverIO, KinetixTriggerMode
 
 KINETIX_TRIGGER_MODE_MAP = {
-    DetectorTrigger.internal: KinetixTriggerMode.internal,
-    DetectorTrigger.constant_gate: KinetixTriggerMode.gate,
-    DetectorTrigger.variable_gate: KinetixTriggerMode.gate,
-    DetectorTrigger.edge_trigger: KinetixTriggerMode.edge,
+    DetectorTrigger.INTERNAL: KinetixTriggerMode.INTERNAL,
+    DetectorTrigger.CONSTANT_GATE: KinetixTriggerMode.GATE,
+    DetectorTrigger.VARIABLE_GATE: KinetixTriggerMode.GATE,
+    DetectorTrigger.EDGE_TRIGGER: KinetixTriggerMode.EDGE,
 }
 
 
-class KinetixController(DetectorController):
+class KinetixController(adcore.ADBaseController[KinetixDriverIO]):
     def __init__(
         self,
         driver: KinetixDriverIO,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
-        self._drv = driver
-        self._arm_status: AsyncStatus | None = None
+        super().__init__(driver, good_states=good_states)
 
     def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
     async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
-            self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger_info.trigger]),
-            self._drv.num_images.set(trigger_info.total_number_of_triggers),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self.driver.trigger_mode.set(
+                KINETIX_TRIGGER_MODE_MAP[trigger_info.trigger]
+            ),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
-            DetectorTrigger.variable_gate,
-            DetectorTrigger.constant_gate,
+            DetectorTrigger.VARIABLE_GATE,
+            DetectorTrigger.CONSTANT_GATE,
         ]:
-            await self._drv.acquire_time.set(trigger_info.livetime)
-
-    async def arm(self):
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self._drv
-        )
-
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)
+            await self.driver.acquire_time.set(trigger_info.livetime)

ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -4,16 +4,16 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class KinetixTriggerMode(StrictEnum):
-    internal = "Internal"
-    edge = "Rising Edge"
-    gate = "Exp. Gate"
+    INTERNAL = "Internal"
+    EDGE = "Rising Edge"
+    GATE = "Exp. Gate"
 
 
 class KinetixReadoutMode(StrictEnum):
-    sensitivity = 1
-    speed = 2
-    dynamic_range = 3
-    sub_electron = 4
+    SENSITIVITY = 1
+    SPEED = 2
+    DYNAMIC_RANGE = 3
+    SUB_ELECTRON = 4
 
 
 class KinetixDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adpilatus/__init__.py

@@ -1,5 +1,5 @@
-from ._pilatus import PilatusDetector, PilatusReadoutTime
-from ._pilatus_controller import PilatusController
+from ._pilatus import PilatusDetector
+from ._pilatus_controller import PilatusController, PilatusReadoutTime
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 __all__ = [

ophyd_async/epics/adpilatus/_pilatus.py

@@ -1,58 +1,46 @@
-from enum import Enum
+from collections.abc import Sequence
 
-from bluesky.protocols import Hints
+from ophyd_async.core import PathProvider
+from ophyd_async.core._signal import SignalR
+from ophyd_async.epics.adcore._core_detector import AreaDetector
+from ophyd_async.epics.adcore._core_io import NDPluginBaseIO
+from ophyd_async.epics.adcore._core_writer import ADWriter
+from ophyd_async.epics.adcore._hdf_writer import ADHDFWriter
 
-from ophyd_async.core import PathProvider, StandardDetector
-from ophyd_async.epics import adcore
-
-from ._pilatus_controller import PilatusController
+from ._pilatus_controller import PilatusController, PilatusReadoutTime
 from ._pilatus_io import PilatusDriverIO
 
 
-#: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-#: The required minimum time difference between ExpPeriod and ExpTime
-#: (readout time) is 2.28 ms
-#: We provide an option to override for newer Pilatus models
-class PilatusReadoutTime(float, Enum):
-    """Pilatus readout time per model in ms"""
-
-    # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-    pilatus2 = 2.28e-3
-
-    # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
-    pilatus3 = 0.95e-3
-
-
-class PilatusDetector(StandardDetector):
+class PilatusDetector(AreaDetector[PilatusController]):
     """A Pilatus StandardDetector writing HDF files"""
 
-    _controller: PilatusController
-    _writer: adcore.ADHDFWriter
-
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
-        readout_time: PilatusReadoutTime = PilatusReadoutTime.pilatus3,
+        readout_time: PilatusReadoutTime = PilatusReadoutTime.PILATUS3,
         drv_suffix: str = "cam1:",
-        hdf_suffix: str = "HDF1:",
+        writer_cls: type[ADWriter] = ADHDFWriter,
+        fileio_suffix: str | None = None,
         name: str = "",
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = PilatusDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = PilatusDriverIO(prefix + drv_suffix)
+        controller = PilatusController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            PilatusController(self.drv, readout_time=readout_time.value),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_time,),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )
-
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -1,9 +1,9 @@
 import asyncio
+from enum import Enum
+from typing import TypeVar, get_args
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
     wait_for_value,
@@ -13,58 +13,83 @@ from ophyd_async.epics import adcore
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 
-class PilatusController(DetectorController):
+#: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+#: The required minimum time difference between ExpPeriod and ExpTime
+#: (readout time) is 2.28 ms
+#: We provide an option to override for newer Pilatus models
+class PilatusReadoutTime(float, Enum):
+    """Pilatus readout time per model in ms"""
+
+    # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+    PILATUS2 = 2.28e-3
+
+    # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
+    PILATUS3 = 0.95e-3
+
+
+PilatusControllerT = TypeVar("PilatusControllerT", bound="PilatusController")
+
+
+class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
     _supported_trigger_types = {
-        DetectorTrigger.internal: PilatusTriggerMode.internal,
-        DetectorTrigger.constant_gate: PilatusTriggerMode.ext_enable,
-        DetectorTrigger.variable_gate: PilatusTriggerMode.ext_enable,
+        DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
+        DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
+        DetectorTrigger.VARIABLE_GATE: PilatusTriggerMode.EXT_ENABLE,
     }
 
     def __init__(
         self,
         driver: PilatusDriverIO,
-        readout_time: float,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        readout_time: float = PilatusReadoutTime.PILATUS3,
     ) -> None:
-        self._drv = driver
+        super().__init__(driver, good_states=good_states)
         self._readout_time = readout_time
-        self._arm_status: AsyncStatus | None = None
+
+    @classmethod
+    def controller_and_drv(
+        cls: type[PilatusControllerT],
+        prefix: str,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        name: str = "",
+        readout_time: float = PilatusReadoutTime.PILATUS3,
+    ) -> tuple[PilatusControllerT, PilatusDriverIO]:
+        driver_cls = get_args(cls.__orig_bases__[0])[0]  # type: ignore
+        driver = driver_cls(prefix, name=name)
+        controller = cls(driver, good_states=good_states, readout_time=readout_time)
+        return controller, driver
 
     def get_deadtime(self, exposure: float | None) -> float:
         return self._readout_time
 
     async def prepare(self, trigger_info: TriggerInfo):
         if trigger_info.livetime is not None:
-            await adcore.set_exposure_time_and_acquire_period_if_supplied(
-                self, self._drv, trigger_info.livetime
+            await self.set_exposure_time_and_acquire_period_if_supplied(
+                trigger_info.livetime
             )
         await asyncio.gather(
-            self._drv.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
-            self._drv.num_images.set(
+            self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
+            self.driver.num_images.set(
                 999_999
                 if trigger_info.total_number_of_triggers == 0
                 else trigger_info.total_number_of_triggers
             ),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
 
     async def arm(self):
         # Standard arm the detector and wait for the acquire PV to be True
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self._drv
-        )
+        self._arm_status = await self.start_acquiring_driver_and_ensure_status()
+
         # The pilatus has an additional PV that goes True when the camserver
         # is actually ready. Should wait for that too or we risk dropping
         # a frame
         await wait_for_value(
-            self._drv.armed,
+            self.driver.armed,
             True,
             timeout=DEFAULT_TIMEOUT,
         )
 
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
     @classmethod
     def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:
         if trigger not in cls._supported_trigger_types.keys():
@@ -74,6 +99,3 @@ class PilatusController(DetectorController):
                 f"use {trigger}"
             )
         return cls._supported_trigger_types[trigger]
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -4,11 +4,11 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv
 
 
 class PilatusTriggerMode(StrictEnum):
-    internal = "Internal"
-    ext_enable = "Ext. Enable"
-    ext_trigger = "Ext. Trigger"
-    mult_trigger = "Mult. Trigger"
-    alignment = "Alignment"
+    INTERNAL = "Internal"
+    EXT_ENABLE = "Ext. Enable"
+    EXT_TRIGGER = "Ext. Trigger"
+    MULT_TRIGGER = "Mult. Trigger"
+    ALIGNMENT = "Alignment"
 
 
 class PilatusDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adsimdetector/__init__.py

@@ -1,7 +1,7 @@
-from ._sim import SimDetector
-from ._sim_controller import SimController
+from ._sim import SimController, SimDetector, SimDriverIO
 
 __all__ = [
-    "SimDetector",
+    "SimDriverIO",
     "SimController",
+    "SimDetector",
 ]

ophyd_async/epics/adsimdetector/_sim.py

@@ -1,35 +1,51 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, SignalR, StandardDetector
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
-from ._sim_controller import SimController
 
+class SimDriverIO(adcore.ADBaseIO): ...
 
-class SimDetector(StandardDetector):
-    _controller: SimController
-    _writer: adcore.ADHDFWriter
 
+class SimController(adcore.ADBaseController[SimDriverIO]):
+    def __init__(
+        self,
+        driver: SimDriverIO,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+    ) -> None:
+        super().__init__(driver, good_states=good_states)
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        return 0.001
+
+
+class SimDetector(adcore.AreaDetector[SimController]):
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
         drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name: str = "",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name="",
         config_sigs: Sequence[SignalR] = (),
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
     ):
-        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = SimDriverIO(prefix + drv_suffix)
+        controller = SimController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            SimController(self.drv),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_period, self.drv.acquire_time, *config_sigs),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )

ophyd_async/epics/advimba/_vimba.py

@@ -1,43 +1,43 @@
-from bluesky.protocols import HasHints, Hints
+from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._vimba_controller import VimbaController
 from ._vimba_io import VimbaDriverIO
 
 
-class VimbaDetector(StandardDetector, HasHints):
+class VimbaDetector(adcore.AreaDetector[VimbaController]):
     """
     Ophyd-async implementation of an ADVimba Detector.
     """
 
-    _controller: VimbaController
-    _writer: adcore.ADHDFWriter
-
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        drv_suffix: str = "cam1:",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = VimbaDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = VimbaDriverIO(prefix + drv_suffix)
+        controller = VimbaController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            VimbaController(self.drv),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_time,),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )
-
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints