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

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -1,13 +1,6 @@
 import asyncio
-from typing import Literal
 
-from ophyd_async.core import (
-    AsyncStatus,
-    DetectorController,
-    DetectorTrigger,
-    TriggerInfo,
-    set_and_wait_for_value,
-)
+from ophyd_async.core import DetectorTrigger, TriggerInfo
 from ophyd_async.epics import adcore
 
 from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
@@ -18,60 +11,35 @@ from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
 _HIGHEST_POSSIBLE_DEADTIME = 1961e-6
 
 
-class AravisController(DetectorController):
-    GPIO_NUMBER = Literal[1, 2, 3, 4]
-
-    def __init__(self, driver: AravisDriverIO, gpio_number: GPIO_NUMBER) -> None:
-        self._drv = driver
-        self.gpio_number = gpio_number
-        self._arm_status: AsyncStatus | None = None
+class AravisController(adcore.ADBaseController[AravisDriverIO]):
+    """`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._drv.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._drv.trigger_mode.set(trigger_mode)
-
-        await asyncio.gather(
-            self._drv.trigger_source.set(trigger_source),
-            self._drv.num_images.set(trigger_info.total_number_of_triggers),
-            self._drv.image_mode.set(image_mode),
-        )
+            await self.driver.acquire_time.set(exposure)
 
-    async def arm(self):
-        self._arm_status = await set_and_wait_for_value(self._drv.acquire, True)
-
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
-    def _get_trigger_info(
-        self, trigger: DetectorTrigger
-    ) -> tuple[AravisTriggerMode, AravisTriggerSource]:
-        supported_trigger_types = (
+        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,
-            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
+        }:
+            # 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:
-            return (AravisTriggerMode.ON, f"Line{self.gpio_number}")  # type: ignore
+            raise ValueError(f"ADAravis does not support {trigger_info.trigger}")
 
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)
+        if trigger_info.total_number_of_triggers == 0:
+            image_mode = adcore.ADImageMode.CONTINUOUS
+        else:
+            image_mode = adcore.ADImageMode.MULTIPLE
+        await asyncio.gather(
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.image_mode.set(image_mode),
+        )

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,22 +1,33 @@
+"""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,
-    ADBaseDatasetDescriber,
-    set_exposure_time_and_acquire_period_if_supplied,
-    start_acquiring_driver_and_ensure_status,
-)
+from ._core_logic import DEFAULT_GOOD_STATES, ADBaseContAcqController, ADBaseController
+from ._core_writer import ADWriter
 from ._hdf_writer import ADHDFWriter
+from ._jpeg_writer import ADJPEGWriter
 from ._single_trigger import SingleTriggerDetector
+from ._tiff_writer import ADTIFFWriter
 from ._utils import (
     ADBaseDataType,
-    FileWriteMode,
-    ImageMode,
+    ADFileWriteMode,
+    ADImageMode,
     NDAttributeDataType,
     NDAttributeParam,
     NDAttributePv,
@@ -26,22 +37,33 @@ from ._utils import (
 
 __all__ = [
     "ADBaseIO",
-    "DetectorState",
+    "ADCallbacks",
+    "ADCompression",
+    "ADBaseContAcqController",
+    "AreaDetector",
+    "ADState",
+    "ContAcqAreaDetector",
     "NDArrayBaseIO",
+    "NDFileIO",
     "NDFileHDFIO",
+    "NDPluginBaseIO",
     "NDPluginStatsIO",
     "DEFAULT_GOOD_STATES",
     "ADBaseDatasetDescriber",
-    "set_exposure_time_and_acquire_period_if_supplied",
-    "start_acquiring_driver_and_ensure_status",
+    "ADBaseController",
+    "ADWriter",
     "ADHDFWriter",
+    "ADTIFFWriter",
+    "ADJPEGWriter",
     "SingleTriggerDetector",
     "ADBaseDataType",
-    "FileWriteMode",
-    "ImageMode",
+    "ADFileWriteMode",
+    "ADImageMode",
     "NDAttributePv",
     "NDAttributeParam",
     "NDAttributeDataType",
     "stop_busy_record",
     "NDAttributePvDbrType",
+    "NDCBFlushOnSoftTrgMode",
+    "NDPluginCBIO",
 ]

ophyd_async/epics/adcore/_core_detector.py

@@ -0,0 +1,81 @@
+from collections.abc import Sequence
+
+from ophyd_async.core import SignalR, StandardDetector
+from ophyd_async.core._providers import PathProvider
+
+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]):
+    def __init__(
+        self,
+        controller: ADBaseControllerT,
+        writer: ADWriter,
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
+        name: str = "",
+    ):
+        self.driver = controller.driver
+        self.fileio = writer.fileio
+
+        if plugins is not None:
+            for name, plugin in plugins.items():
+                setattr(self, name, plugin)
+
+        super().__init__(
+            controller,
+            writer,
+            (self.driver.acquire_period, self.driver.acquire_time, *config_sigs),
+            name=name,
+        )
+
+    def get_plugin(
+        self, name: str, plugin_type: type[NDPluginBaseIO] = NDPluginBaseIO
+    ) -> NDPluginBaseIO:
+        plugin = getattr(self, name, None)
+        if not isinstance(plugin, plugin_type):
+            raise TypeError(
+                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,
+        )

ophyd_async/epics/adcore/_core_io.py

@@ -1,75 +1,96 @@
-from ophyd_async.core import Device, StrictEnum
-from ophyd_async.epics.core import (
-    epics_signal_r,
-    epics_signal_rw,
-    epics_signal_rw_rbv,
-)
+import asyncio
+from typing import Annotated as A
 
-from ._utils import ADBaseDataType, FileWriteMode, ImageMode
+from ophyd_async.core import DatasetDescriber, SignalR, SignalRW, StrictEnum
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
+from ._utils import ADBaseDataType, ADFileWriteMode, ADImageMode, convert_ad_dtype_to_np
 
-class Callback(StrictEnum):
+
+class ADCallbacks(StrictEnum):
     ENABLE = "Enable"
     DISABLE = "Disable"
 
 
-class NDArrayBaseIO(Device):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
-        self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
-        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
-        self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
-        self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
-        self.data_type = epics_signal_r(ADBaseDataType, prefix + "DataType_RBV")
-        self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
-        # There is no _RBV for this one
-        self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")
-        super().__init__(name=name)
+class NDArrayBaseIO(EpicsDevice):
+    """Class responsible for passing detector data from drivers to pluglins.
+
+    This mirrors the interface provided by ADCore/db/NDArrayBase.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDArray.html
+    """
 
+    unique_id: A[SignalR[int], PvSuffix("UniqueId_RBV")]
+    nd_attributes_file: A[SignalRW[str], PvSuffix("NDAttributesFile")]
+    acquire: A[SignalRW[bool], PvSuffix.rbv("Acquire")]
+    array_size_x: A[SignalR[int], PvSuffix("ArraySizeX_RBV")]
+    array_size_y: A[SignalR[int], PvSuffix("ArraySizeY_RBV")]
+    data_type: A[SignalR[ADBaseDataType], PvSuffix("DataType_RBV")]
+    array_counter: A[SignalRW[int], PvSuffix.rbv("ArrayCounter")]
+    # There is no _RBV for this one
+    wait_for_plugins: A[SignalRW[bool], PvSuffix("WaitForPlugins")]
 
-class NDPluginBaseIO(NDArrayBaseIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
-        self.enable_callbacks = epics_signal_rw_rbv(
-            Callback, prefix + "EnableCallbacks"
+
+class ADBaseDatasetDescriber(DatasetDescriber):
+    def __init__(self, driver: NDArrayBaseIO) -> None:
+        self._driver = driver
+
+    async def np_datatype(self) -> str:
+        return convert_ad_dtype_to_np(await self._driver.data_type.get_value())
+
+    async def shape(self) -> tuple[int, int]:
+        shape = await asyncio.gather(
+            self._driver.array_size_y.get_value(),
+            self._driver.array_size_x.get_value(),
         )
-        self.nd_array_address = epics_signal_rw_rbv(int, prefix + "NDArrayAddress")
-        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0_RBV")
-        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1_RBV")
-        super().__init__(prefix, name)
+        return shape
 
 
-class NDPluginStatsIO(NDPluginBaseIO):
-    """
-    Plugin for computing statistics from an image or region of interest within an image.
+class NDPluginBaseIO(NDArrayBaseIO):
+    """Base class from which plugins are derived.
+
+    This mirrors the interface provided by ADCore/db/NDPluginBase.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginDriver.html
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        # Basic statistics
-        self.compute_statistics = epics_signal_rw(bool, prefix + "ComputeStatistics")
-        self.bgd_width = epics_signal_rw(int, prefix + "BgdWidth")
-        self.total_array = epics_signal_rw(float, prefix + "TotalArray")
-        # Centroid statistics
-        self.compute_centroid = epics_signal_rw(bool, prefix + "ComputeCentroid")
-        self.centroid_threshold = epics_signal_rw(float, prefix + "CentroidThreshold")
-        # X and Y Profiles
-        self.compute_profiles = epics_signal_rw(bool, prefix + "ComputeProfiles")
-        self.profile_size_x = epics_signal_rw(int, prefix + "ProfileSizeX")
-        self.profile_size_y = epics_signal_rw(int, prefix + "ProfileSizeY")
-        self.cursor_x = epics_signal_rw(int, prefix + "CursorX")
-        self.cursor_y = epics_signal_rw(int, prefix + "CursorY")
-        # Array Histogram
-        self.compute_histogram = epics_signal_rw(bool, prefix + "ComputeHistogram")
-        self.hist_size = epics_signal_rw(int, prefix + "HistSize")
-        self.hist_min = epics_signal_rw(float, prefix + "HistMin")
-        self.hist_max = epics_signal_rw(float, prefix + "HistMax")
-        super().__init__(prefix, name)
-
-
-class DetectorState(StrictEnum):
+    nd_array_port: A[SignalRW[str], PvSuffix.rbv("NDArrayPort")]
+    enable_callbacks: A[SignalRW[ADCallbacks], PvSuffix.rbv("EnableCallbacks")]
+    nd_array_address: A[SignalRW[int], PvSuffix.rbv("NDArrayAddress")]
+    array_size0: A[SignalR[int], PvSuffix("ArraySize0_RBV")]
+    array_size1: A[SignalR[int], PvSuffix("ArraySize1_RBV")]
+    queue_size: A[SignalRW[int], PvSuffix.rbv("QueueSize")]
+
+
+class NDPluginStatsIO(NDPluginBaseIO):
+    """Plugin for computing statistics from an image or ROI within an image.
+
+    This mirrors the interface provided by ADCore/db/NDStats.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginStats.html
     """
-    Default set of states of an AreaDetector driver.
-    See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore
+
+    # Basic statistics
+    compute_statistics: A[SignalRW[bool], PvSuffix.rbv("ComputeStatistics")]
+    bgd_width: A[SignalRW[int], PvSuffix.rbv("BgdWidth")]
+    total_array: A[SignalRW[float], PvSuffix.rbv("TotalArray")]
+    # Centroid statistics
+    compute_centroid: A[SignalRW[bool], PvSuffix.rbv("ComputeCentroid")]
+    centroid_threshold: A[SignalRW[float], PvSuffix.rbv("CentroidThreshold")]
+    # X and Y Profiles
+    compute_profiles: A[SignalRW[bool], PvSuffix.rbv("ComputeProfiles")]
+    profile_size_x: A[SignalRW[int], PvSuffix.rbv("ProfileSizeX")]
+    profile_size_y: A[SignalRW[int], PvSuffix.rbv("ProfileSizeY")]
+    cursor_x: A[SignalRW[int], PvSuffix.rbv("CursorX")]
+    cursor_y: A[SignalRW[int], PvSuffix.rbv("CursorY")]
+    # Array Histogram
+    compute_histogram: A[SignalRW[bool], PvSuffix.rbv("ComputeHistogram")]
+    hist_size: A[SignalRW[int], PvSuffix.rbv("HistSize")]
+    hist_min: A[SignalRW[float], PvSuffix.rbv("HistMin")]
+    hist_max: A[SignalRW[float], PvSuffix.rbv("HistMax")]
+
+
+class ADState(StrictEnum):
+    """Default set of states of an AreaDetector driver.
+
+    See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore.
     """
 
     IDLE = "Idle"
@@ -86,19 +107,20 @@ class DetectorState(StrictEnum):
 
 
 class ADBaseIO(NDArrayBaseIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        # Define some signals
-        self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
-        self.acquire_period = epics_signal_rw_rbv(float, prefix + "AcquirePeriod")
-        self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
-        self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
-        self.detector_state = epics_signal_r(
-            DetectorState, prefix + "DetectorState_RBV"
-        )
-        super().__init__(prefix, name=name)
+    """Base class from which areaDetector drivers are derived.
+
+    This mirrors the interface provided by ADCore/db/ADBase.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/ADDriver.html
+    """
+
+    acquire_time: A[SignalRW[float], PvSuffix.rbv("AcquireTime")]
+    acquire_period: A[SignalRW[float], PvSuffix.rbv("AcquirePeriod")]
+    num_images: A[SignalRW[int], PvSuffix.rbv("NumImages")]
+    image_mode: A[SignalRW[ADImageMode], PvSuffix.rbv("ImageMode")]
+    detector_state: A[SignalR[ADState], PvSuffix("DetectorState_RBV")]
 
 
-class Compression(StrictEnum):
+class ADCompression(StrictEnum):
     NONE = "None"
     NBIT = "N-bit"
     SZIP = "szip"
@@ -109,30 +131,58 @@ class Compression(StrictEnum):
     JPEG = "JPEG"
 
 
-class NDFileHDFIO(NDPluginBaseIO):
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        self.position_mode = epics_signal_rw_rbv(bool, prefix + "PositionMode")
-        self.compression = epics_signal_rw_rbv(Compression, prefix + "Compression")
-        self.num_extra_dims = epics_signal_rw_rbv(int, prefix + "NumExtraDims")
-        self.file_path = epics_signal_rw_rbv(str, prefix + "FilePath")
-        self.file_name = epics_signal_rw_rbv(str, prefix + "FileName")
-        self.file_path_exists = epics_signal_r(bool, prefix + "FilePathExists_RBV")
-        self.file_template = epics_signal_rw_rbv(str, prefix + "FileTemplate")
-        self.full_file_name = epics_signal_r(str, prefix + "FullFileName_RBV")
-        self.file_write_mode = epics_signal_rw_rbv(
-            FileWriteMode, prefix + "FileWriteMode"
-        )
-        self.num_capture = epics_signal_rw_rbv(int, prefix + "NumCapture")
-        self.num_captured = epics_signal_r(int, prefix + "NumCaptured_RBV")
-        self.swmr_mode = epics_signal_rw_rbv(bool, prefix + "SWMRMode")
-        self.lazy_open = epics_signal_rw_rbv(bool, prefix + "LazyOpen")
-        self.capture = epics_signal_rw_rbv(bool, prefix + "Capture")
-        self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
-        self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
-        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0")
-        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1")
-        self.create_directory = epics_signal_rw(int, prefix + "CreateDirectory")
-        self.num_frames_chunks = epics_signal_r(int, prefix + "NumFramesChunks_RBV")
-        self.chunk_size_auto = epics_signal_rw_rbv(bool, prefix + "ChunkSizeAuto")
-        super().__init__(prefix, name)
+class NDFileIO(NDPluginBaseIO):
+    """Base class from which file plugins are derived.
+
+    This mirrors the interface provided by ADCore/db/NDFile.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginFile.html
+    """
+
+    file_path: A[SignalRW[str], PvSuffix.rbv("FilePath")]
+    file_name: A[SignalRW[str], PvSuffix.rbv("FileName")]
+    file_path_exists: A[SignalR[bool], PvSuffix("FilePathExists_RBV")]
+    file_template: A[SignalRW[str], PvSuffix.rbv("FileTemplate")]
+    full_file_name: A[SignalR[str], PvSuffix("FullFileName_RBV")]
+    file_number: A[SignalRW[int], PvSuffix("FileNumber")]
+    auto_increment: A[SignalRW[bool], PvSuffix("AutoIncrement")]
+    file_write_mode: A[SignalRW[ADFileWriteMode], PvSuffix.rbv("FileWriteMode")]
+    num_capture: A[SignalRW[int], PvSuffix.rbv("NumCapture")]
+    num_captured: A[SignalR[int], PvSuffix("NumCaptured_RBV")]
+    capture: A[SignalRW[bool], PvSuffix.rbv("Capture")]
+    array_size0: A[SignalR[int], PvSuffix("ArraySize0")]
+    array_size1: A[SignalR[int], PvSuffix("ArraySize1")]
+    create_directory: A[SignalRW[int], PvSuffix("CreateDirectory")]
+
+
+class NDFileHDFIO(NDFileIO):
+    """Plugin for storing data in HDF5 file format.
+
+    This mirrors the interface provided by ADCore/db/NDFileHDF5.template.
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDFileHDF5.html
+    """
+
+    position_mode: A[SignalRW[bool], PvSuffix.rbv("PositionMode")]
+    compression: A[SignalRW[ADCompression], PvSuffix.rbv("Compression")]
+    num_extra_dims: A[SignalRW[int], PvSuffix.rbv("NumExtraDims")]
+    swmr_mode: A[SignalRW[bool], PvSuffix.rbv("SWMRMode")]
+    flush_now: A[SignalRW[bool], PvSuffix("FlushNow")]
+    xml_file_name: A[SignalRW[str], PvSuffix.rbv("XMLFileName")]
+    num_frames_chunks: A[SignalR[int], PvSuffix("NumFramesChunks_RBV")]
+    chunk_size_auto: A[SignalRW[bool], PvSuffix.rbv("ChunkSizeAuto")]
+    lazy_open: A[SignalRW[bool], PvSuffix.rbv("LazyOpen")]
+
+
+class NDCBFlushOnSoftTrgMode(StrictEnum):
+    ON_NEW_IMAGE = "OnNewImage"
+    IMMEDIATELY = "Immediately"
+
+
+class NDPluginCBIO(NDPluginBaseIO):
+    pre_count: A[SignalRW[int], PvSuffix.rbv("PreCount")]
+    post_count: A[SignalRW[int], PvSuffix.rbv("PostCount")]
+    preset_trigger_count: A[SignalRW[int], PvSuffix.rbv("PresetTriggerCount")]
+    trigger: A[SignalRW[bool], PvSuffix.rbv("Trigger")]
+    capture: A[SignalRW[bool], PvSuffix.rbv("Capture")]
+    flush_on_soft_trg: A[
+        SignalRW[NDCBFlushOnSoftTrgMode], PvSuffix.rbv("FlushOnSoftTrg")
+    ]