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

ophyd_async/epics/adcore/_hdf_writer.py

@@ -3,17 +3,15 @@ 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,
     DatasetDescriber,
-    HDFDataset,
-    HDFFile,
+    HDFDatasetDescription,
+    HDFDocumentComposer,
     NameProvider,
     PathProvider,
-    wait_for_value,
 )
 
 from ._core_io import NDFileHDFIO, NDPluginBaseIO
@@ -25,6 +23,8 @@ from ._utils import (
 
 
 class ADHDFWriter(ADWriter[NDFileHDFIO]):
+    """Allow `NDFileHDFIO` to be used within `StandardDetector`."""
+
     default_suffix: str = "HDF1:"
 
     def __init__(
@@ -44,12 +44,12 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
             file_extension=".h5",
             mimetype="application/x-hdf5",
         )
-        self._datasets: list[HDFDataset] = []
-        self._file: HDFFile | None = None
-        self._include_file_number = False
+        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
+        self._composer = None
 
         # Setting HDF writer specific signals
 
@@ -63,11 +63,6 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
             self.fileio.xml_file_name.set(""),
         )
 
-        # By default, don't add file number to filename
-        self._filename_template = "%s%s"
-        if self._include_file_number:
-            self._filename_template += "_%6.6d"
-
         # Set common AD file plugin params, begin capturing
         await self.begin_capture()
 
@@ -82,7 +77,7 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
 
         # Add the main data
         self._datasets = [
-            HDFDataset(
+            HDFDatasetDescription(
                 data_key=name,
                 dataset="/entry/data/data",
                 shape=detector_shape,
@@ -99,7 +94,7 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
             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")
@@ -109,15 +104,15 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
                             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,
                         )
                     )
 
@@ -139,9 +134,9 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         # TODO: fail if we get dropped frames
         await self.fileio.flush_now.set(True)
         if indices_written:
-            if not self._file:
+            if not self._composer:
                 path = Path(await self.fileio.full_file_name.get_value())
-                self._file = HDFFile(
+                self._composer = HDFDocumentComposer(
                     # See https://github.com/bluesky/ophyd-async/issues/122
                     path,
                     self._datasets,
@@ -150,19 +145,7 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
                 # 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.fileio.capture.set(False, wait=False)
-        await wait_for_value(self.fileio.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/_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):
@@ -35,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/_utils.py

@@ -79,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(SubsetEnum):
+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

@@ -13,9 +13,9 @@ from ._kinetix_io import KinetixDriverIO
 
 
 class KinetixDetector(AreaDetector[KinetixController]):
-    """
-    Ophyd-async implementation of an ADKinetix Detector.
-    https://github.com/NSLS-II/ADKinetix
+    """Ophyd-async implementation of an ADKinetix Detector.
+
+    https://github.com/NSLS-II/ADKinetix.
     """
 
     def __init__(

ophyd_async/epics/adkinetix/_kinetix_controller.py

@@ -17,10 +17,12 @@ KINETIX_TRIGGER_MODE_MAP = {
 
 
 class KinetixController(adcore.ADBaseController[KinetixDriverIO]):
+    """Controller for adkinetix detector."""
+
     def __init__(
         self,
         driver: KinetixDriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
         super().__init__(driver, good_states=good_states)
 
@@ -33,7 +35,7 @@ class KinetixController(adcore.ADBaseController[KinetixDriverIO]):
                 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),
+            self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
             DetectorTrigger.VARIABLE_GATE,

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,3 +1,8 @@
+"""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

ophyd_async/epics/adpilatus/_pilatus.py

@@ -12,7 +12,7 @@ from ._pilatus_io import PilatusDriverIO
 
 
 class PilatusDetector(AreaDetector[PilatusController]):
-    """A Pilatus StandardDetector writing HDF files"""
+    """A Pilatus StandardDetector writing HDF files."""
 
     def __init__(
         self,

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -1,6 +1,5 @@
 import asyncio
 from enum import Enum
-from typing import TypeVar, get_args
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -13,12 +12,8 @@ from ophyd_async.epics import adcore
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 
-#: 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"""
+    """Pilatus readout time per model in ms."""
 
     # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
     PILATUS2 = 2.28e-3
@@ -27,10 +22,9 @@ class PilatusReadoutTime(float, Enum):
     PILATUS3 = 0.95e-3
 
 
-PilatusControllerT = TypeVar("PilatusControllerT", bound="PilatusController")
-
-
 class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
+    """`DetectorController` for a `PilatusDriverIO`."""
+
     _supported_trigger_types = {
         DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
         DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
@@ -40,25 +34,12 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
     def __init__(
         self,
         driver: PilatusDriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
         readout_time: float = PilatusReadoutTime.PILATUS3,
     ) -> None:
         super().__init__(driver, good_states=good_states)
         self._readout_time = readout_time
 
-    @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
 
@@ -74,7 +55,7 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
                 if trigger_info.total_number_of_triggers == 0
                 else trigger_info.total_number_of_triggers
             ),
-            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
+            self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
 
     async def arm(self):

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -1,9 +1,13 @@
-from ophyd_async.core import StrictEnum
+from typing import Annotated as A
+
+from ophyd_async.core import SignalR, SignalRW, StrictEnum
 from ophyd_async.epics import adcore
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv
+from ophyd_async.epics.core import PvSuffix
 
 
 class PilatusTriggerMode(StrictEnum):
+    """Trigger modes for ADPilatus detector."""
+
     INTERNAL = "Internal"
     EXT_ENABLE = "Ext. Enable"
     EXT_TRIGGER = "Ext. Trigger"
@@ -12,11 +16,9 @@ class PilatusTriggerMode(StrictEnum):
 
 
 class PilatusDriverIO(adcore.ADBaseIO):
-    """This mirrors the interface provided by ADPilatus/db/pilatus.template."""
+    """Driver for the Pilatus pixel array detectors."""
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.trigger_mode = epics_signal_rw_rbv(
-            PilatusTriggerMode, prefix + "TriggerMode"
-        )
-        self.armed = epics_signal_r(bool, prefix + "Armed")
-        super().__init__(prefix, name)
+    """This mirrors the interface provided by ADPilatus/db/pilatus.template."""
+    """See HTML docs at https://areadetector.github.io/areaDetector/ADPilatus/pilatusDoc.html"""
+    trigger_mode: A[SignalRW[PilatusTriggerMode], PvSuffix.rbv("TriggerMode")]
+    armed: A[SignalR[bool], PvSuffix.rbv("Armed_RBV")]

ophyd_async/epics/adsimdetector/__init__.py

@@ -1,4 +1,11 @@
-from ._sim import SimController, SimDetector, SimDriverIO
+"""Support for the ADAravis areaDetector driver.
+
+https://github.com/areaDetector/ADSimDetector
+"""
+
+from ._sim import SimDetector
+from ._sim_controller import SimController
+from ._sim_io import SimDriverIO
 
 __all__ = [
     "SimDriverIO",

ophyd_async/epics/adsimdetector/_sim.py

@@ -3,23 +3,13 @@ from collections.abc import Sequence
 from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
-
-class SimDriverIO(adcore.ADBaseIO): ...
-
-
-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
+from ._sim_controller import SimController
+from ._sim_io import SimDriverIO
 
 
 class SimDetector(adcore.AreaDetector[SimController]):
+    """Detector for simulated Areadetector."""
+
     def __init__(
         self,
         prefix: str,

ophyd_async/epics/adsimdetector/_sim_controller.py

@@ -0,0 +1,17 @@
+from ophyd_async.epics import adcore
+
+from ._sim_io import SimDriverIO
+
+
+class SimController(adcore.ADBaseController[SimDriverIO]):
+    """Controller for simulated Areadetector."""
+
+    def __init__(
+        self,
+        driver: SimDriverIO,
+        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
+    ) -> None:
+        super().__init__(driver, good_states=good_states)
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        return 0.001

ophyd_async/epics/adsimdetector/_sim_io.py

@@ -0,0 +1,10 @@
+from ophyd_async.epics import adcore
+
+
+class SimDriverIO(adcore.ADBaseIO):
+    """Base class for driving simulated Areadetector IO.
+
+    This mirrors the interface provided by ADSimDetector/db/simDetector.template.
+    """
+
+    pass

ophyd_async/epics/advimba/__init__.py

@@ -1,6 +1,13 @@
 from ._vimba import VimbaDetector
 from ._vimba_controller import VimbaController
-from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
+from ._vimba_io import (
+    VimbaConvertFormat,
+    VimbaDriverIO,
+    VimbaExposeOutMode,
+    VimbaOnOff,
+    VimbaOverlap,
+    VimbaTriggerSource,
+)
 
 __all__ = [
     "VimbaDetector",
@@ -9,4 +16,6 @@ __all__ = [
     "VimbaExposeOutMode",
     "VimbaOnOff",
     "VimbaTriggerSource",
+    "VimbaOverlap",
+    "VimbaConvertFormat",
 ]

ophyd_async/epics/advimba/_vimba.py

@@ -8,8 +8,9 @@ from ._vimba_io import VimbaDriverIO
 
 
 class VimbaDetector(adcore.AreaDetector[VimbaController]):
-    """
-    Ophyd-async implementation of an ADVimba Detector.
+    """Ophyd-async implementation of an ADVimba Detector.
+
+    https://github.com/areaDetector/ADVimba
     """
 
     def __init__(

ophyd_async/epics/advimba/_vimba_controller.py

@@ -24,10 +24,12 @@ EXPOSE_OUT_MODE = {
 
 
 class VimbaController(adcore.ADBaseController[VimbaDriverIO]):
+    """Controller for the Vimba detector."""
+
     def __init__(
         self,
         driver: VimbaDriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
         super().__init__(driver, good_states=good_states)
 
@@ -39,7 +41,7 @@ class VimbaController(adcore.ADBaseController[VimbaDriverIO]):
             self.driver.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
             self.driver.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
             self.driver.num_images.set(trigger_info.total_number_of_triggers),
-            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
+            self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
             DetectorTrigger.VARIABLE_GATE,

ophyd_async/epics/advimba/_vimba_io.py

@@ -1,17 +1,13 @@
-from ophyd_async.core import StrictEnum
-from ophyd_async.epics import adcore
-from ophyd_async.epics.core import epics_signal_rw_rbv
-
+from typing import Annotated as A
 
-class VimbaPixelFormat(StrictEnum):
-    INTERNAL = "Mono8"
-    EXT_ENABLE = "Mono12"
-    EXT_TRIGGER = "Ext. Trigger"
-    MULT_TRIGGER = "Mult. Trigger"
-    ALIGNMENT = "Alignment"
+from ophyd_async.core import SignalRW, StrictEnum
+from ophyd_async.epics import adcore
+from ophyd_async.epics.core import PvSuffix
 
 
 class VimbaConvertFormat(StrictEnum):
+    """Convert pixel format for the Vimba detector."""
+
     NONE = "None"
     MONO8 = "Mono8"
     MONO16 = "Mono16"
@@ -20,6 +16,8 @@ class VimbaConvertFormat(StrictEnum):
 
 
 class VimbaTriggerSource(StrictEnum):
+    """Mode for the source of triggers on the Vimbda."""
+
     FREERUN = "Freerun"
     LINE1 = "Line1"
     LINE2 = "Line2"
@@ -30,36 +28,33 @@ class VimbaTriggerSource(StrictEnum):
 
 
 class VimbaOverlap(StrictEnum):
+    """Overlap modes for the Vimba detector."""
+
     OFF = "Off"
     PREV_FRAME = "PreviousFrame"
 
 
 class VimbaOnOff(StrictEnum):
+    """On/Off modes on the Vimba detector."""
+
     ON = "On"
     OFF = "Off"
 
 
 class VimbaExposeOutMode(StrictEnum):
+    """Exposure control modes for Vimba detectors."""
+
     TIMED = "Timed"  # Use ExposureTime PV
     TRIGGER_WIDTH = "TriggerWidth"  # Expose for length of high signal
 
 
 class VimbaDriverIO(adcore.ADBaseIO):
-    """This mirrors the interface provided by ADVimba/db/vimba.template."""
-
-    def __init__(self, prefix: str, name: str = "") -> None:
-        # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
-        self.convert_pixel_format = epics_signal_rw_rbv(
-            VimbaConvertFormat, prefix + "ConvertPixelFormat"
-        )  # Pixel format of data outputted to AD
-        self.trigger_source = epics_signal_rw_rbv(
-            VimbaTriggerSource, prefix + "TriggerSource"
-        )
-        self.trigger_mode = epics_signal_rw_rbv(VimbaOnOff, prefix + "TriggerMode")
-        self.trigger_overlap = epics_signal_rw_rbv(
-            VimbaOverlap, prefix + "TriggerOverlap"
-        )
-        self.exposure_mode = epics_signal_rw_rbv(
-            VimbaExposeOutMode, prefix + "ExposureMode"
-        )
-        super().__init__(prefix, name)
+    """Mirrors the interface provided by ADVimba/db/vimba.template."""
+
+    convert_pixel_format: A[
+        SignalRW[VimbaConvertFormat], PvSuffix("ConvertPixelFormat")
+    ]
+    trigger_source: A[SignalRW[VimbaTriggerSource], PvSuffix("TriggerSource")]
+    trigger_mode: A[SignalRW[VimbaOnOff], PvSuffix("TriggerMode")]
+    trigger_overlap: A[SignalRW[VimbaOverlap], PvSuffix("TriggerOverlap")]
+    exposure_mode: A[SignalRW[VimbaExposeOutMode], PvSuffix("ExposureMode")]