ophyd-async 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

ophyd_async/epics/{areadetector/drivers/aravis_driver.py → adaravis/_aravis_io.py}

@@ -1,8 +1,8 @@
 from enum import Enum
 
 from ophyd_async.core import SubsetEnum
-from ophyd_async.epics.areadetector.drivers import ADBase
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_rw_rbv
 
 
 class AravisTriggerMode(str, Enum):
@@ -22,12 +22,15 @@ class AravisTriggerMode(str, Enum):
 AravisTriggerSource = SubsetEnum["Freerun", "Line1"]
 
 
-class AravisDriver(ADBase):
+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)$"
+
+    This mirrors the interface provided by ADAravis/db/aravisCamera.template.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:

ophyd_async/epics/adcore/__init__.py

@@ -0,0 +1,36 @@
+from ._core_io import ADBaseIO, DetectorState, NDFileHDFIO, NDPluginStatsIO
+from ._core_logic import (
+    DEFAULT_GOOD_STATES,
+    ADBaseShapeProvider,
+    set_exposure_time_and_acquire_period_if_supplied,
+    start_acquiring_driver_and_ensure_status,
+)
+from ._hdf_writer import ADHDFWriter
+from ._single_trigger import SingleTriggerDetector
+from ._utils import (
+    ADBaseDataType,
+    FileWriteMode,
+    ImageMode,
+    NDAttributeDataType,
+    NDAttributesXML,
+    stop_busy_record,
+)
+
+__all__ = [
+    "ADBaseIO",
+    "DetectorState",
+    "NDFileHDFIO",
+    "NDPluginStatsIO",
+    "DEFAULT_GOOD_STATES",
+    "ADBaseShapeProvider",
+    "set_exposure_time_and_acquire_period_if_supplied",
+    "start_acquiring_driver_and_ensure_status",
+    "ADHDFWriter",
+    "SingleTriggerDetector",
+    "ADBaseDataType",
+    "FileWriteMode",
+    "ImageMode",
+    "NDAttributeDataType",
+    "NDAttributesXML",
+    "stop_busy_record",
+]

ophyd_async/epics/adcore/_core_io.py

@@ -0,0 +1,114 @@
+from enum import Enum
+
+from ophyd_async.core import Device
+from ophyd_async.epics.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+)
+
+from ._utils import ADBaseDataType, FileWriteMode, ImageMode
+
+
+class Callback(str, Enum):
+    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 + "NDDataType_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 NDPluginBaseIO(NDArrayBaseIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
+        self.enable_callback = epics_signal_rw_rbv(Callback, prefix + "EnableCallbacks")
+        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)
+
+
+class NDPluginStatsIO(NDPluginBaseIO):
+    pass
+
+
+class DetectorState(str, Enum):
+    """
+    Default set of states of an AreaDetector driver.
+    See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore
+    """
+
+    Idle = "Idle"
+    Acquire = "Acquire"
+    Readout = "Readout"
+    Correct = "Correct"
+    Saving = "Saving"
+    Aborting = "Aborting"
+    Error = "Error"
+    Waiting = "Waiting"
+    Initializing = "Initializing"
+    Disconnected = "Disconnected"
+    Aborted = "Aborted"
+
+
+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)
+
+
+class Compression(str, Enum):
+    none = "None"
+    nbit = "N-bit"
+    szip = "szip"
+    zlib = "zlib"
+    blosc = "Blosc"
+    bslz4 = "BSLZ4"
+    lz4 = "LZ4"
+    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_dir_depth = epics_signal_rw(int, prefix + "CreateDirectory")
+        super().__init__(prefix, name)

ophyd_async/epics/{areadetector/drivers/ad_base.py → adcore/_core_logic.py}

@@ -1,5 +1,4 @@
 import asyncio
-from enum import Enum
 from typing import FrozenSet, Set
 
 from ophyd_async.core import (
@@ -10,53 +9,31 @@ from ophyd_async.core import (
     set_and_wait_for_value,
 )
 
-from ...signal.signal import epics_signal_r, epics_signal_rw_rbv
-from ..utils import ImageMode
-from ..writers.nd_plugin import NDArrayBase
+from ._core_io import ADBaseIO, DetectorState
 
-
-class DetectorState(str, Enum):
-    """
-    Default set of states of an AreaDetector driver.
-    See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore
-    """
-
-    Idle = "Idle"
-    Acquire = "Acquire"
-    Readout = "Readout"
-    Correct = "Correct"
-    Saving = "Saving"
-    Aborting = "Aborting"
-    Error = "Error"
-    Waiting = "Waiting"
-    Initializing = "Initializing"
-    Disconnected = "Disconnected"
-    Aborted = "Aborted"
-
-
-#: Default set of states that we should consider "good" i.e. the acquisition
+# Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
 DEFAULT_GOOD_STATES: FrozenSet[DetectorState] = frozenset(
     [DetectorState.Idle, DetectorState.Aborted]
 )
 
 
-class ADBase(NDArrayBase):
-    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"
+class ADBaseShapeProvider(ShapeProvider):
+    def __init__(self, driver: ADBaseIO) -> None:
+        self._driver = driver
+
+    async def __call__(self) -> tuple:
+        shape = await asyncio.gather(
+            self._driver.array_size_y.get_value(),
+            self._driver.array_size_x.get_value(),
+            self._driver.data_type.get_value(),
         )
-        super().__init__(prefix, name=name)
+        return shape
 
 
 async def set_exposure_time_and_acquire_period_if_supplied(
     controller: DetectorControl,
-    driver: ADBase,
+    driver: ADBaseIO,
     exposure: float | None = None,
     timeout: float = DEFAULT_TIMEOUT,
 ) -> None:
@@ -70,7 +47,7 @@ async def set_exposure_time_and_acquire_period_if_supplied(
     controller:
         Controller that can supply a deadtime.
     driver:
-        The driver to start acquiring. Must subclass ADBase.
+        The driver to start acquiring. Must subclass ADBaseIO.
     exposure:
         Desired exposure time, this is a noop if it is None.
     timeout:
@@ -85,7 +62,7 @@ async def set_exposure_time_and_acquire_period_if_supplied(
 
 
 async def start_acquiring_driver_and_ensure_status(
-    driver: ADBase,
+    driver: ADBaseIO,
     good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES),
     timeout: float = DEFAULT_TIMEOUT,
 ) -> AsyncStatus:
@@ -99,7 +76,7 @@ async def start_acquiring_driver_and_ensure_status(
     Parameters
     ----------
     driver:
-        The driver to start acquiring. Must subclass ADBase.
+        The driver to start acquiring. Must subclass ADBaseIO.
     good_states:
         set of states defined in DetectorState enum which are considered good states.
     timeout:
@@ -125,16 +102,3 @@ async def start_acquiring_driver_and_ensure_status(
             )
 
     return AsyncStatus(complete_acquisition())
-
-
-class ADBaseShapeProvider(ShapeProvider):
-    def __init__(self, driver: ADBase) -> None:
-        self._driver = driver
-
-    async def __call__(self) -> tuple:
-        shape = await asyncio.gather(
-            self._driver.array_size_y.get_value(),
-            self._driver.array_size_x.get_value(),
-            self._driver.data_type.get_value(),
-        )
-        return shape

ophyd_async/epics/{areadetector/writers/hdf_writer.py → adcore/_hdf_writer.py}

@@ -8,23 +8,24 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     DetectorWriter,
+    HDFDataset,
+    HDFFile,
     NameProvider,
     PathProvider,
     ShapeProvider,
+    observe_value,
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.core.signal import observe_value
 
-from .general_hdffile import _HDFDataset, _HDFFile
-from .nd_file_hdf import FileWriteMode, NDFileHDF
-from .nd_plugin import convert_ad_dtype_to_np
+from ._core_io import NDFileHDFIO
+from ._utils import FileWriteMode, convert_ad_dtype_to_np
 
 
-class HDFWriter(DetectorWriter):
+class ADHDFWriter(DetectorWriter):
     def __init__(
         self,
-        hdf: NDFileHDF,
+        hdf: NDFileHDFIO,
         path_provider: PathProvider,
         name_provider: NameProvider,
         shape_provider: ShapeProvider,
@@ -36,8 +37,8 @@ class HDFWriter(DetectorWriter):
         self._shape_provider = shape_provider
         self._scalar_datasets_paths = scalar_datasets_paths
         self._capture_status: Optional[AsyncStatus] = None
-        self._datasets: List[_HDFDataset] = []
-        self._file: Optional[_HDFFile] = None
+        self._datasets: List[HDFDataset] = []
+        self._file: Optional[HDFFile] = None
         self._multiplier = 1
 
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
@@ -80,7 +81,7 @@ class HDFWriter(DetectorWriter):
 
         # Add the main data
         self._datasets = [
-            _HDFDataset(
+            HDFDataset(
                 data_key=name,
                 dataset="/entry/data/data",
                 shape=frame_shape,
@@ -91,7 +92,7 @@ class HDFWriter(DetectorWriter):
         # And all the scalar datasets
         for ds_name, ds_path in self._scalar_datasets_paths.items():
             self._datasets.append(
-                _HDFDataset(
+                HDFDataset(
                     f"{name}-{ds_name}",
                     f"/entry/instrument/NDAttributes/{ds_path}",
                     (),
@@ -131,7 +132,7 @@ class HDFWriter(DetectorWriter):
         if indices_written:
             if not self._file:
                 path = Path(await self.hdf.full_file_name.get_value())
-                self._file = _HDFFile(
+                self._file = HDFFile(
                     self._path_provider(),
                     # See https://github.com/bluesky/ophyd-async/issues/122
                     path,

ophyd_async/epics/{areadetector/single_trigger_det.py → adcore/_single_trigger.py}

@@ -11,18 +11,17 @@ from ophyd_async.core import (
     StandardReadable,
 )
 
-from .drivers.ad_base import ADBase
-from .utils import ImageMode
-from .writers.nd_plugin import NDPluginBase
+from ._core_io import ADBaseIO, NDPluginBaseIO
+from ._utils import ImageMode
 
 
-class SingleTriggerDet(StandardReadable, Triggerable):
+class SingleTriggerDetector(StandardReadable, Triggerable):
     def __init__(
         self,
-        drv: ADBase,
+        drv: ADBaseIO,
         read_uncached: Sequence[SignalR] = (),
         name="",
-        **plugins: NDPluginBase,
+        **plugins: NDPluginBaseIO,
     ) -> None:
         self.drv = drv
         self.__dict__.update(plugins)

ophyd_async/epics/{areadetector/utils.py → adcore/_utils.py}

@@ -5,6 +5,35 @@ from xml.etree import cElementTree as ET
 from ophyd_async.core import DEFAULT_TIMEOUT, SignalRW, T, wait_for_value
 
 
+class ADBaseDataType(str, Enum):
+    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",
+    }
+    return ad_dtype_to_np_dtype[ad_dtype]
+
+
 class FileWriteMode(str, Enum):
     single = "Single"
     capture = "Capture"

ophyd_async/epics/adkinetix/__init__.py

@@ -0,0 +1,9 @@
+from ._kinetix import KinetixDetector
+from ._kinetix_controller import KinetixController
+from ._kinetix_io import KinetixDriverIO
+
+__all__ = [
+    "KinetixDetector",
+    "KinetixController",
+    "KinetixDriverIO",
+]

ophyd_async/epics/{areadetector/kinetix.py → adkinetix/_kinetix.py}

@@ -1,12 +1,10 @@
 from bluesky.protocols import HasHints, Hints
 
 from ophyd_async.core import PathProvider, StandardDetector
-from ophyd_async.epics.areadetector.controllers.kinetix_controller import (
-    KinetixController,
-)
-from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
-from ophyd_async.epics.areadetector.drivers.kinetix_driver import KinetixDriver
-from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
+from ophyd_async.epics import adcore
+
+from ._kinetix_controller import KinetixController
+from ._kinetix_io import KinetixDriverIO
 
 
 class KinetixDetector(StandardDetector, HasHints):
@@ -16,7 +14,7 @@ class KinetixDetector(StandardDetector, HasHints):
     """
 
     _controller: KinetixController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
@@ -26,16 +24,16 @@ class KinetixDetector(StandardDetector, HasHints):
         hdf_suffix="HDF1:",
         name="",
     ):
-        self.drv = KinetixDriver(prefix + drv_suffix)
-        self.hdf = NDFileHDF(prefix + hdf_suffix)
+        self.drv = KinetixDriverIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             KinetixController(self.drv),
-            HDFWriter(
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/{areadetector/controllers/kinetix_controller.py → adkinetix/_kinetix_controller.py}

@@ -2,12 +2,9 @@ import asyncio
 from typing import Optional
 
 from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
-from ophyd_async.epics.areadetector.drivers.ad_base import (
-    start_acquiring_driver_and_ensure_status,
-)
+from ophyd_async.epics import adcore
 
-from ..drivers.kinetix_driver import KinetixDriver, KinetixTriggerMode
-from ..utils import ImageMode, stop_busy_record
+from ._kinetix_io import KinetixDriverIO, KinetixTriggerMode
 
 KINETIX_TRIGGER_MODE_MAP = {
     DetectorTrigger.internal: KinetixTriggerMode.internal,
@@ -20,7 +17,7 @@ KINETIX_TRIGGER_MODE_MAP = {
 class KinetixController(DetectorControl):
     def __init__(
         self,
-        driver: KinetixDriver,
+        driver: KinetixDriverIO,
     ) -> None:
         self._drv = driver
 
@@ -36,14 +33,14 @@ class KinetixController(DetectorControl):
         await asyncio.gather(
             self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger]),
             self._drv.num_images.set(num),
-            self._drv.image_mode.set(ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
         if exposure is not None and trigger not in [
             DetectorTrigger.variable_gate,
             DetectorTrigger.constant_gate,
         ]:
             await self._drv.acquire_time.set(exposure)
-        return await start_acquiring_driver_and_ensure_status(self._drv)
+        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/{areadetector/drivers/kinetix_driver.py → adkinetix/_kinetix_io.py}

@@ -1,8 +1,7 @@
 from enum import Enum
 
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
-
-from .ad_base import ADBase
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_rw_rbv
 
 
 class KinetixTriggerMode(str, Enum):
@@ -17,7 +16,9 @@ class KinetixReadoutMode(str, Enum):
     dynamic_range = 3
 
 
-class KinetixDriver(ADBase):
+class KinetixDriverIO(adcore.ADBaseIO):
+    """This mirrors the interface provided by ADKinetix/db/ADKinetix.template."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
         self.trigger_mode = epics_signal_rw_rbv(

ophyd_async/epics/adpilatus/__init__.py

@@ -0,0 +1,11 @@
+from ._pilatus import PilatusDetector, PilatusReadoutTime
+from ._pilatus_controller import PilatusController
+from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
+
+__all__ = [
+    "PilatusDetector",
+    "PilatusReadoutTime",
+    "PilatusController",
+    "PilatusDriverIO",
+    "PilatusTriggerMode",
+]

ophyd_async/epics/{areadetector/pilatus.py → adpilatus/_pilatus.py}

@@ -2,15 +2,11 @@ from enum import Enum
 
 from bluesky.protocols import Hints
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core.detector import StandardDetector
-from ophyd_async.epics.areadetector.controllers.pilatus_controller import (
-    PilatusController,
-)
-from ophyd_async.epics.areadetector.drivers.ad_base import ADBaseShapeProvider
-from ophyd_async.epics.areadetector.drivers.pilatus_driver import PilatusDriver
-from ophyd_async.epics.areadetector.writers.hdf_writer import HDFWriter
-from ophyd_async.epics.areadetector.writers.nd_file_hdf import NDFileHDF
+from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.epics import adcore
+
+from ._pilatus_controller import PilatusController
+from ._pilatus_io import PilatusDriverIO
 
 
 #: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
@@ -31,7 +27,7 @@ class PilatusDetector(StandardDetector):
     """A Pilatus StandardDetector writing HDF files"""
 
     _controller: PilatusController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
@@ -42,16 +38,16 @@ class PilatusDetector(StandardDetector):
         hdf_suffix: str = "HDF1:",
         name: str = "",
     ):
-        self.drv = PilatusDriver(prefix + drv_suffix)
-        self.hdf = NDFileHDF(prefix + hdf_suffix)
+        self.drv = PilatusDriverIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             PilatusController(self.drv, readout_time=readout_time.value),
-            HDFWriter(
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/{areadetector/controllers/pilatus_controller.py → adpilatus/_pilatus_controller.py}

@@ -1,18 +1,16 @@
 import asyncio
 from typing import Optional
 
-from ophyd_async.core import DEFAULT_TIMEOUT, wait_for_value
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.detector import DetectorControl, DetectorTrigger
-from ophyd_async.epics.areadetector.drivers.ad_base import (
-    set_exposure_time_and_acquire_period_if_supplied,
-    start_acquiring_driver_and_ensure_status,
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    wait_for_value,
 )
-from ophyd_async.epics.areadetector.drivers.pilatus_driver import (
-    PilatusDriver,
-    PilatusTriggerMode,
-)
-from ophyd_async.epics.areadetector.utils import ImageMode, stop_busy_record
+from ophyd_async.epics import adcore
+
+from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 
 class PilatusController(DetectorControl):
@@ -24,7 +22,7 @@ class PilatusController(DetectorControl):
 
     def __init__(
         self,
-        driver: PilatusDriver,
+        driver: PilatusDriverIO,
         readout_time: float,
     ) -> None:
         self._drv = driver
@@ -40,17 +38,17 @@ class PilatusController(DetectorControl):
         exposure: Optional[float] = None,
     ) -> AsyncStatus:
         if exposure is not None:
-            await set_exposure_time_and_acquire_period_if_supplied(
+            await adcore.set_exposure_time_and_acquire_period_if_supplied(
                 self, self._drv, exposure
             )
         await asyncio.gather(
             self._drv.trigger_mode.set(self._get_trigger_mode(trigger)),
             self._drv.num_images.set(999_999 if num == 0 else num),
-            self._drv.image_mode.set(ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
 
         # Standard arm the detector and wait for the acquire PV to be True
-        idle_status = await start_acquiring_driver_and_ensure_status(self._drv)
+        idle_status = await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
         # The pilatus has an additional PV that goes True when the camserver
         # is actually ready. Should wait for that too or we risk dropping
@@ -74,4 +72,4 @@ class PilatusController(DetectorControl):
         return cls._supported_trigger_types[trigger]
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)