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

ophyd_async/epics/adandor/_andor_io.py

@@ -0,0 +1,36 @@
+from ophyd_async.core import StrictEnum, SubsetEnum
+from ophyd_async.epics.adcore import ADBaseIO
+from ophyd_async.epics.core import (
+    epics_signal_r,
+    epics_signal_rw,
+)
+
+
+class Andor2TriggerMode(StrictEnum):
+    INTERNAL = "Internal"
+    EXT_TRIGGER = "External"
+    EXT_START = "External Start"
+    EXT_EXPOSURE = "External Exposure"
+    EXT_FVP = "External FVP"
+    SOFTWARE = "Software"
+
+
+class Andor2DataType(SubsetEnum):
+    UINT16 = "UInt16"
+    UINT32 = "UInt32"
+    FLOAT32 = "Float32"
+    FLOAT64 = "Float64"
+
+
+class Andor2DriverIO(ADBaseIO):
+    """
+    Epics pv for andor model:DU897_BV as deployed on p99
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(prefix, name=name)
+        self.trigger_mode = epics_signal_rw(Andor2TriggerMode, prefix + "TriggerMode")
+        self.data_type = epics_signal_r(Andor2DataType, prefix + "DataType_RBV")
+        self.andor_accumulate_period = epics_signal_r(
+            float, prefix + "AndorAccumulatePeriod_RBV"
+        )

ophyd_async/epics/adaravis/__init__.py

@@ -1,9 +1,11 @@
 from ._aravis import AravisDetector
 from ._aravis_controller import AravisController
-from ._aravis_io import AravisDriverIO
+from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
 
 __all__ = [
     "AravisDetector",
     "AravisController",
     "AravisDriverIO",
+    "AravisTriggerMode",
+    "AravisTriggerSource",
 ]

ophyd_async/epics/adaravis/_aravis.py

@@ -1,61 +1,47 @@
-from typing import get_args
+from collections.abc import Sequence
 
-from bluesky.protocols import HasHints, Hints
-
-from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.core import PathProvider
+from ophyd_async.core._signal import SignalR
 from ophyd_async.epics import adcore
 
 from ._aravis_controller import AravisController
 from ._aravis_io import AravisDriverIO
 
 
-class AravisDetector(StandardDetector, HasHints):
+class AravisDetector(adcore.AreaDetector[AravisController]):
     """
     Ophyd-async implementation of an ADAravis Detector.
     The detector may be configured for an external trigger on a GPIO port,
     which must be done prior to preparing the detector
     """
 
-    _controller: AravisController
-    _writer: adcore.ADHDFWriter
-
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
         drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
         gpio_number: AravisController.GPIO_NUMBER = 1,
+        config_sigs: Sequence[SignalR] = (),
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
     ):
-        self.drv = AravisDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = AravisDriverIO(prefix + drv_suffix)
+        controller = AravisController(driver, gpio_number=gpio_number)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            AravisController(self.drv, gpio_number=gpio_number),
-            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,
         )
-
-    def get_external_trigger_gpio(self):
-        return self._controller.gpio_number
-
-    def set_external_trigger_gpio(self, gpio_number: AravisController.GPIO_NUMBER):
-        supported_gpio_numbers = get_args(AravisController.GPIO_NUMBER)
-        if gpio_number not in supported_gpio_numbers:
-            raise ValueError(
-                f"{self.__class__.__name__} only supports the following GPIO "
-                f"indices: {supported_gpio_numbers} but was asked to "
-                f"use {gpio_number}"
-            )
-        self._controller.gpio_number = gpio_number
-
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -2,11 +2,8 @@ import asyncio
 from typing import Literal
 
 from ophyd_async.core import (
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
-    set_and_wait_for_value,
 )
 from ophyd_async.epics import adcore
 
@@ -18,49 +15,46 @@ from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
 _HIGHEST_POSSIBLE_DEADTIME = 1961e-6
 
 
-class AravisController(DetectorController):
+class AravisController(adcore.ADBaseController[AravisDriverIO]):
     GPIO_NUMBER = Literal[1, 2, 3, 4]
 
-    def __init__(self, driver: AravisDriverIO, gpio_number: GPIO_NUMBER) -> None:
-        self._drv = driver
+    def __init__(
+        self,
+        driver: AravisDriverIO,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        gpio_number: GPIO_NUMBER = 1,
+    ) -> None:
+        super().__init__(driver, good_states=good_states)
         self.gpio_number = gpio_number
-        self._arm_status: AsyncStatus | None = None
 
     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
+            image_mode = adcore.ImageMode.CONTINUOUS
         else:
-            image_mode = adcore.ImageMode.multiple
+            image_mode = adcore.ImageMode.MULTIPLE
         if (exposure := trigger_info.livetime) is not None:
-            await self._drv.acquire_time.set(exposure)
+            await self.driver.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 self.driver.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),
+            self.driver.trigger_source.set(trigger_source),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.image_mode.set(image_mode),
         )
 
-    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 = (
-            DetectorTrigger.constant_gate,
-            DetectorTrigger.edge_trigger,
-            DetectorTrigger.internal,
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.EDGE_TRIGGER,
+            DetectorTrigger.INTERNAL,
         )
         if trigger not in supported_trigger_types:
             raise ValueError(
@@ -68,10 +62,7 @@ class AravisController(DetectorController):
                 f"types: {supported_trigger_types} but was asked to "
                 f"use {trigger}"
             )
-        if trigger == DetectorTrigger.internal:
-            return AravisTriggerMode.off, AravisTriggerSource.freerun
+        if trigger == DetectorTrigger.INTERNAL:
+            return AravisTriggerMode.OFF, AravisTriggerSource.FREERUN
         else:
-            return (AravisTriggerMode.on, f"Line{self.gpio_number}")  # type: ignore
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)
+            return (AravisTriggerMode.ON, f"Line{self.gpio_number}")  # type: ignore

ophyd_async/epics/adaravis/_aravis_io.py

@@ -6,8 +6,8 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 class AravisTriggerMode(StrictEnum):
     """GigEVision GenICAM standard: on=externally triggered"""
 
-    on = "On"
-    off = "Off"
+    ON = "On"
+    OFF = "Off"
 
 
 """A minimal set of TriggerSources that must be supported by the underlying record.
@@ -20,8 +20,8 @@ class AravisTriggerMode(StrictEnum):
 
 
 class AravisTriggerSource(SubsetEnum):
-    freerun = "Freerun"
-    line1 = "Line1"
+    FREERUN = "Freerun"
+    LINE1 = "Line1"
 
 
 class AravisDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adcore/__init__.py

@@ -1,18 +1,20 @@
+from ._core_detector import AreaDetector
 from ._core_io import (
+    ADBaseDatasetDescriber,
     ADBaseIO,
     DetectorState,
     NDArrayBaseIO,
     NDFileHDFIO,
+    NDFileIO,
+    NDPluginBaseIO,
     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, 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,
@@ -26,15 +28,20 @@ from ._utils import (
 
 __all__ = [
     "ADBaseIO",
+    "AreaDetector",
     "DetectorState",
     "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",

ophyd_async/epics/adcore/_core_detector.py

@@ -0,0 +1,41 @@
+from collections.abc import Sequence
+
+from ophyd_async.core import SignalR, StandardDetector
+
+from ._core_io import NDPluginBaseIO
+from ._core_logic import ADBaseControllerT
+from ._core_writer import ADWriter
+
+
+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

ophyd_async/epics/adcore/_core_io.py

@@ -1,16 +1,19 @@
+import asyncio
+
 from ophyd_async.core import Device, StrictEnum
+from ophyd_async.core._providers import DatasetDescriber
 from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
 )
 
-from ._utils import ADBaseDataType, FileWriteMode, ImageMode
+from ._utils import ADBaseDataType, FileWriteMode, ImageMode, convert_ad_dtype_to_np
 
 
 class Callback(StrictEnum):
-    Enable = "Enable"
-    Disable = "Disable"
+    ENABLE = "Enable"
+    DISABLE = "Disable"
 
 
 class NDArrayBaseIO(Device):
@@ -27,6 +30,21 @@ class NDArrayBaseIO(Device):
         super().__init__(name=name)
 
 
+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(),
+        )
+        return shape
+
+
 class NDPluginBaseIO(NDArrayBaseIO):
     def __init__(self, prefix: str, name: str = "") -> None:
         self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
@@ -36,6 +54,7 @@ class NDPluginBaseIO(NDArrayBaseIO):
         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")
+        self.queue_size = epics_signal_rw(int, prefix + "QueueSize")
         super().__init__(prefix, name)
 
 
@@ -72,17 +91,17 @@ class DetectorState(StrictEnum):
     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"
+    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):
@@ -99,40 +118,46 @@ class ADBaseIO(NDArrayBaseIO):
 
 
 class Compression(StrictEnum):
-    none = "None"
-    nbit = "N-bit"
-    szip = "szip"
-    zlib = "zlib"
-    blosc = "Blosc"
-    bslz4 = "BSLZ4"
-    lz4 = "LZ4"
-    jpeg = "JPEG"
+    NONE = "None"
+    NBIT = "N-bit"
+    SZIP = "szip"
+    ZLIB = "zlib"
+    BLOSC = "Blosc"
+    BSLZ4 = "BSLZ4"
+    LZ4 = "LZ4"
+    JPEG = "JPEG"
 
 
-class NDFileHDFIO(NDPluginBaseIO):
+class NDFileIO(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_number = epics_signal_rw(int, prefix + "FileNumber")
+        self.auto_increment = epics_signal_rw(bool, prefix + "AutoIncrement")
         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")
+        super().__init__(prefix, name)
+
+
+class NDFileHDFIO(NDFileIO):
+    def __init__(self, prefix: str, name="") -> None:
+        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.swmr_mode = epics_signal_rw_rbv(bool, prefix + "SWMRMode")
+        self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
+        self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
         self.num_frames_chunks = epics_signal_r(int, prefix + "NumFramesChunks_RBV")
         self.chunk_size_auto = epics_signal_rw_rbv(bool, prefix + "ChunkSizeAuto")
+        self.lazy_open = epics_signal_rw_rbv(bool, prefix + "LazyOpen")
         super().__init__(prefix, name)