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

ophyd_async/epics/adcore/_hdf_writer.py

@@ -1,89 +1,71 @@
 import asyncio
-from collections.abc import AsyncGenerator, AsyncIterator
+from collections.abc import AsyncIterator
 from pathlib import Path
 from xml.etree import ElementTree as ET
 
-from bluesky.protocols import Hints, StreamAsset
+from bluesky.protocols import StreamAsset
 from event_model import DataKey
 
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    AsyncStatus,
     DatasetDescriber,
-    DetectorWriter,
-    HDFDataset,
-    HDFFile,
+    HDFDatasetDescription,
+    HDFDocumentComposer,
     NameProvider,
     PathProvider,
-    observe_value,
-    set_and_wait_for_value,
-    wait_for_value,
 )
 
-from ._core_io import Callback, NDArrayBaseIO, NDFileHDFIO
+from ._core_io import NDFileHDFIO, NDPluginBaseIO
+from ._core_writer import ADWriter
 from ._utils import (
-    FileWriteMode,
     convert_param_dtype_to_np,
     convert_pv_dtype_to_np,
 )
 
 
-class ADHDFWriter(DetectorWriter):
+class ADHDFWriter(ADWriter[NDFileHDFIO]):
+    """Allow `NDFileHDFIO` to be used within `StandardDetector`."""
+
+    default_suffix: str = "HDF1:"
+
     def __init__(
         self,
-        hdf: NDFileHDFIO,
+        fileio: NDFileHDFIO,
         path_provider: PathProvider,
         name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
-        *plugins: NDArrayBaseIO,
+        plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
-        self.hdf = hdf
-        self._path_provider = path_provider
-        self._name_provider = name_provider
-        self._dataset_describer = dataset_describer
-
-        self._plugins = plugins
-        self._capture_status: AsyncStatus | None = None
-        self._datasets: list[HDFDataset] = []
-        self._file: HDFFile | None = None
-        self._multiplier = 1
+        super().__init__(
+            fileio,
+            path_provider,
+            name_provider,
+            dataset_describer,
+            plugins=plugins,
+            file_extension=".h5",
+            mimetype="application/x-hdf5",
+        )
+        self._datasets: list[HDFDatasetDescription] = []
+        self._composer: HDFDocumentComposer | None = None
+        self._filename_template = "%s%s"
 
     async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
-        self._file = None
-        info = self._path_provider(device_name=self._name_provider())
+        self._composer = None
 
-        # Set the directory creation depth first, since dir creation callback happens
-        # when directory path PV is processed.
-        await self.hdf.create_directory.set(info.create_dir_depth)
+        # Setting HDF writer specific signals
 
         # Make sure we are using chunk auto-sizing
-        await asyncio.gather(self.hdf.chunk_size_auto.set(True))
+        await asyncio.gather(self.fileio.chunk_size_auto.set(True))
 
         await asyncio.gather(
-            self.hdf.num_extra_dims.set(0),
-            self.hdf.lazy_open.set(True),
-            self.hdf.swmr_mode.set(True),
-            # See https://github.com/bluesky/ophyd-async/issues/122
-            self.hdf.file_path.set(str(info.directory_path)),
-            self.hdf.file_name.set(info.filename),
-            self.hdf.file_template.set("%s/%s.h5"),
-            self.hdf.file_write_mode.set(FileWriteMode.STREAM),
-            # Never use custom xml layout file but use the one defined
-            # in the source code file NDFileHDF5LayoutXML.cpp
-            self.hdf.xml_file_name.set(""),
-            self.hdf.enable_callbacks.set(Callback.ENABLE),
+            self.fileio.num_extra_dims.set(0),
+            self.fileio.lazy_open.set(True),
+            self.fileio.swmr_mode.set(True),
+            self.fileio.xml_file_name.set(""),
         )
 
-        assert (
-            await self.hdf.file_path_exists.get_value()
-        ), f"File path {info.directory_path} for hdf plugin does not exist"
+        # Set common AD file plugin params, begin capturing
+        await self.begin_capture()
 
-        # Overwrite num_capture to go forever
-        await self.hdf.num_capture.set(0)
-        # Wait for it to start, stashing the status that tells us when it finishes
-        self._capture_status = await set_and_wait_for_value(
-            self.hdf.capture, True, wait_for_set_completion=False
-        )
         name = self._name_provider()
         detector_shape = await self._dataset_describer.shape()
         np_dtype = await self._dataset_describer.np_datatype()
@@ -91,11 +73,11 @@ class ADHDFWriter(DetectorWriter):
         outer_shape = (multiplier,) if multiplier > 1 else ()
 
         # Determine number of frames that will be saved per HDF chunk
-        frames_per_chunk = await self.hdf.num_frames_chunks.get_value()
+        frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
 
         # Add the main data
         self._datasets = [
-            HDFDataset(
+            HDFDatasetDescription(
                 data_key=name,
                 dataset="/entry/data/data",
                 shape=detector_shape,
@@ -105,14 +87,14 @@ class ADHDFWriter(DetectorWriter):
             )
         ]
         # And all the scalar datasets
-        for plugin in self._plugins:
+        for plugin in self._plugins.values():
             maybe_xml = await plugin.nd_attributes_file.get_value()
             # This is the check that ADCore does to see if it is an XML string
             # rather than a filename to parse
             if "<Attributes>" in maybe_xml:
                 root = ET.fromstring(maybe_xml)
                 for child in root:
-                    datakey = child.attrib["name"]
+                    data_key = child.attrib["name"]
                     if child.attrib.get("type", "EPICS_PV") == "EPICS_PV":
                         np_datatype = convert_pv_dtype_to_np(
                             child.attrib.get("dbrtype", "DBR_NATIVE")
@@ -122,21 +104,21 @@ class ADHDFWriter(DetectorWriter):
                             child.attrib.get("datatype", "INT")
                         )
                     self._datasets.append(
-                        HDFDataset(
-                            datakey,
-                            f"/entry/instrument/NDAttributes/{datakey}",
-                            (),
-                            np_datatype,
-                            multiplier,
+                        HDFDatasetDescription(
+                            data_key=data_key,
+                            dataset=f"/entry/instrument/NDAttributes/{data_key}",
+                            shape=(),
+                            dtype_numpy=np_datatype,
                             # NDAttributes appear to always be configured with
                             # this chunk size
                             chunk_shape=(16384,),
+                            multiplier=multiplier,
                         )
                     )
 
         describe = {
             ds.data_key: DataKey(
-                source=self.hdf.full_file_name.source,
+                source=self.fileio.full_file_name.source,
                 shape=list(outer_shape + tuple(ds.shape)),
                 dtype="array" if ds.shape else "number",
                 dtype_numpy=ds.dtype_numpy,
@@ -146,26 +128,15 @@ class ADHDFWriter(DetectorWriter):
         }
         return describe
 
-    async def observe_indices_written(
-        self, timeout=DEFAULT_TIMEOUT
-    ) -> AsyncGenerator[int, None]:
-        """Wait until a specific index is ready to be collected"""
-        async for num_captured in observe_value(self.hdf.num_captured, timeout):
-            yield num_captured // self._multiplier
-
-    async def get_indices_written(self) -> int:
-        num_captured = await self.hdf.num_captured.get_value()
-        return num_captured // self._multiplier
-
     async def collect_stream_docs(
         self, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
-        await self.hdf.flush_now.set(True)
+        await self.fileio.flush_now.set(True)
         if indices_written:
-            if not self._file:
-                path = Path(await self.hdf.full_file_name.get_value())
-                self._file = HDFFile(
+            if not self._composer:
+                path = Path(await self.fileio.full_file_name.get_value())
+                self._composer = HDFDocumentComposer(
                     # See https://github.com/bluesky/ophyd-async/issues/122
                     path,
                     self._datasets,
@@ -174,19 +145,7 @@ class ADHDFWriter(DetectorWriter):
                 # stream datum says "here are N frames in that stream resource",
                 # you get one stream resource and many stream datums per scan
 
-                for doc in self._file.stream_resources():
+                for doc in self._composer.stream_resources():
                     yield "stream_resource", doc
-            for doc in self._file.stream_data(indices_written):
+            for doc in self._composer.stream_data(indices_written):
                 yield "stream_datum", doc
-
-    async def close(self):
-        # Already done a caput callback in _capture_status, so can't do one here
-        await self.hdf.capture.set(False, wait=False)
-        await wait_for_value(self.hdf.capture, False, DEFAULT_TIMEOUT)
-        if self._capture_status:
-            # We kicked off an open, so wait for it to return
-            await self._capture_status
-
-    @property
-    def hints(self) -> Hints:
-        return {"fields": [self._name_provider()]}

ophyd_async/epics/adcore/_jpeg_writer.py

@@ -0,0 +1,26 @@
+from ophyd_async.core import DatasetDescriber, NameProvider, PathProvider
+
+from ._core_io import NDFileIO, NDPluginBaseIO
+from ._core_writer import ADWriter
+
+
+class ADJPEGWriter(ADWriter[NDFileIO]):
+    default_suffix: str = "JPEG1:"
+
+    def __init__(
+        self,
+        fileio: NDFileIO,
+        path_provider: PathProvider,
+        name_provider: NameProvider,
+        dataset_describer: DatasetDescriber,
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+    ) -> None:
+        super().__init__(
+            fileio,
+            path_provider,
+            name_provider,
+            dataset_describer,
+            plugins=plugins,
+            file_extension=".jpg",
+            mimetype="multipart/related;type=image/jpeg",
+        )

ophyd_async/epics/adcore/_single_trigger.py

@@ -7,7 +7,7 @@ from ophyd_async.core import AsyncStatus, SignalR, StandardReadable
 from ophyd_async.core import StandardReadableFormat as Format
 
 from ._core_io import ADBaseIO, NDPluginBaseIO
-from ._utils import ImageMode
+from ._utils import ADImageMode
 
 
 class SingleTriggerDetector(StandardReadable, Triggerable):
@@ -16,11 +16,12 @@ class SingleTriggerDetector(StandardReadable, Triggerable):
         drv: ADBaseIO,
         read_uncached: Sequence[SignalR] = (),
         name="",
-        **plugins: NDPluginBaseIO,
+        plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
         self.drv = drv
-        for k, v in plugins.items():
-            setattr(self, k, v)
+        if plugins is not None:
+            for k, v in plugins.items():
+                setattr(self, k, v)
 
         self.add_readables(
             [self.drv.array_counter, *read_uncached],
@@ -34,7 +35,7 @@ class SingleTriggerDetector(StandardReadable, Triggerable):
     @AsyncStatus.wrap
     async def stage(self) -> None:
         await asyncio.gather(
-            self.drv.image_mode.set(ImageMode.SINGLE),
+            self.drv.image_mode.set(ADImageMode.SINGLE),
             self.drv.wait_for_plugins.set(True),
         )
         await super().stage()

ophyd_async/epics/adcore/_tiff_writer.py

@@ -0,0 +1,26 @@
+from ophyd_async.core import DatasetDescriber, NameProvider, PathProvider
+
+from ._core_io import NDFileIO, NDPluginBaseIO
+from ._core_writer import ADWriter
+
+
+class ADTIFFWriter(ADWriter[NDFileIO]):
+    default_suffix: str = "TIFF1:"
+
+    def __init__(
+        self,
+        fileio: NDFileIO,
+        path_provider: PathProvider,
+        name_provider: NameProvider,
+        dataset_describer: DatasetDescriber,
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+    ) -> None:
+        super().__init__(
+            fileio,
+            path_provider,
+            name_provider,
+            dataset_describer,
+            plugins=plugins,
+            file_extension=".tiff",
+            mimetype="multipart/related;type=image/tiff",
+        )

ophyd_async/epics/adcore/_utils.py

@@ -6,6 +6,7 @@ from ophyd_async.core import (
     SignalR,
     SignalRW,
     StrictEnum,
+    SubsetEnum,
     wait_for_value,
 )
 
@@ -78,13 +79,13 @@ def convert_param_dtype_to_np(datatype: str) -> str:
     return np_datatype
 
 
-class FileWriteMode(StrictEnum):
+class ADFileWriteMode(StrictEnum):
     SINGLE = "Single"
     CAPTURE = "Capture"
     STREAM = "Stream"
 
 
-class ImageMode(StrictEnum):
+class ADImageMode(SubsetEnum):
     SINGLE = "Single"
     MULTIPLE = "Multiple"
     CONTINUOUS = "Continuous"

ophyd_async/epics/adkinetix/__init__.py

@@ -1,10 +1,11 @@
 from ._kinetix import KinetixDetector
 from ._kinetix_controller import KinetixController
-from ._kinetix_io import KinetixDriverIO, KinetixTriggerMode
+from ._kinetix_io import KinetixDriverIO, KinetixReadoutMode, KinetixTriggerMode
 
 __all__ = [
     "KinetixDetector",
     "KinetixController",
     "KinetixDriverIO",
     "KinetixTriggerMode",
+    "KinetixReadoutMode",
 ]

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):
-    """
-    Ophyd-async implementation of an ADKinetix Detector.
-    https://github.com/NSLS-II/ADKinetix
-    """
+class KinetixDetector(AreaDetector[KinetixController]):
+    """Ophyd-async implementation of an ADKinetix Detector.
 
-    _controller: KinetixController
-    _writer: adcore.ADHDFWriter
+    https://github.com/NSLS-II/ADKinetix.
+    """
 
     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,
 )
@@ -18,37 +16,29 @@ KINETIX_TRIGGER_MODE_MAP = {
 }
 
 
-class KinetixController(DetectorController):
+class KinetixController(adcore.ADBaseController[KinetixDriverIO]):
+    """Controller for adkinetix detector."""
+
     def __init__(
         self,
         driver: KinetixDriverIO,
+        good_states: frozenset[adcore.ADState] = 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.ADImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
             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

@@ -1,15 +1,21 @@
-from ophyd_async.core import StrictEnum
+from typing import Annotated as A
+
+from ophyd_async.core import SignalRW, StrictEnum
 from ophyd_async.epics import adcore
-from ophyd_async.epics.core import epics_signal_rw_rbv
+from ophyd_async.epics.core import PvSuffix
 
 
 class KinetixTriggerMode(StrictEnum):
+    """Trigger mode for ADKinetix detector."""
+
     INTERNAL = "Internal"
     EDGE = "Rising Edge"
     GATE = "Exp. Gate"
 
 
 class KinetixReadoutMode(StrictEnum):
+    """Readout mode for ADKinetix detector."""
+
     SENSITIVITY = 1
     SPEED = 2
     DYNAMIC_RANGE = 3
@@ -17,14 +23,7 @@ class KinetixReadoutMode(StrictEnum):
 
 
 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(
-            KinetixTriggerMode, prefix + "TriggerMode"
-        )
-        self.readout_port_idx = epics_signal_rw_rbv(
-            KinetixReadoutMode, prefix + "ReadoutPortIdx"
-        )
-        super().__init__(prefix, name)
+    """Mirrors the interface provided by ADKinetix/db/ADKinetix.template."""
+
+    trigger_mode: A[SignalRW[KinetixTriggerMode], PvSuffix("TriggerMode")]
+    readout_port_idx: A[SignalRW[KinetixReadoutMode], PvSuffix("ReadoutPortIdx")]

ophyd_async/epics/adpilatus/__init__.py

@@ -1,5 +1,10 @@
-from ._pilatus import PilatusDetector, PilatusReadoutTime
-from ._pilatus_controller import PilatusController
+"""Support for the ADPilatus areaDetector driver.
+
+https://github.com/areaDetector/ADPilatus
+"""
+
+from ._pilatus import PilatusDetector
+from ._pilatus_controller import PilatusController, PilatusReadoutTime
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 __all__ = [

ophyd_async/epics/adpilatus/_pilatus.py

@@ -1,33 +1,18 @@
-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):
-    """A Pilatus StandardDetector writing HDF files"""
-
-    _controller: PilatusController
-    _writer: adcore.ADHDFWriter
+class PilatusDetector(AreaDetector[PilatusController]):
+    """A Pilatus StandardDetector writing HDF files."""
 
     def __init__(
         self,
@@ -35,24 +20,27 @@ class PilatusDetector(StandardDetector):
         path_provider: PathProvider,
         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