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

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,13 +15,17 @@ 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
@@ -35,25 +36,18 @@ class AravisController(DetectorController):
         else:
             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]:
@@ -72,6 +66,3 @@ class AravisController(DetectorController):
             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)

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,11 +1,14 @@
+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):
@@ -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)
 
 
@@ -109,30 +128,36 @@ class Compression(StrictEnum):
     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)

ophyd_async/epics/adcore/_core_logic.py

@@ -1,15 +1,17 @@
 import asyncio
+from typing import Generic, TypeVar
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    DatasetDescriber,
     DetectorController,
+    DetectorTrigger,
+    TriggerInfo,
     set_and_wait_for_value,
 )
-from ophyd_async.epics.adcore._utils import convert_ad_dtype_to_np
 
 from ._core_io import ADBaseIO, DetectorState
+from ._utils import ImageMode, stop_busy_record
 
 # Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
@@ -17,93 +19,103 @@ DEFAULT_GOOD_STATES: frozenset[DetectorState] = frozenset(
     [DetectorState.IDLE, DetectorState.ABORTED]
 )
 
-
-class ADBaseDatasetDescriber(DatasetDescriber):
-    def __init__(self, driver: ADBaseIO) -> 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(),
+ADBaseIOT = TypeVar("ADBaseIOT", bound=ADBaseIO)
+ADBaseControllerT = TypeVar("ADBaseControllerT", bound="ADBaseController")
+
+
+class ADBaseController(DetectorController, Generic[ADBaseIOT]):
+    def __init__(
+        self,
+        driver: ADBaseIOT,
+        good_states: frozenset[DetectorState] = DEFAULT_GOOD_STATES,
+    ) -> None:
+        self.driver = driver
+        self.good_states = good_states
+        self.frame_timeout = DEFAULT_TIMEOUT
+        self._arm_status: AsyncStatus | None = None
+
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        if trigger_info.trigger != DetectorTrigger.INTERNAL:
+            msg = (
+                "fly scanning (i.e. external triggering) is not supported for this "
+                "device"
+            )
+            raise TypeError(msg)
+        self.frame_timeout = (
+            DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         )
-        return shape
-
-
-async def set_exposure_time_and_acquire_period_if_supplied(
-    controller: DetectorController,
-    driver: ADBaseIO,
-    exposure: float | None = None,
-    timeout: float = DEFAULT_TIMEOUT,
-) -> None:
-    """
-    Sets the exposure time if it is not None and the acquire period to the
-    exposure time plus the deadtime. This is expected behavior for most
-    AreaDetectors, but some may require more specialized handling.
-
-    Parameters
-    ----------
-    controller:
-        Controller that can supply a deadtime.
-    driver:
-        The driver to start acquiring. Must subclass ADBaseIO.
-    exposure:
-        Desired exposure time, this is a noop if it is None.
-    timeout:
-        How long to wait for the exposure time and acquire period to be set.
-    """
-    if exposure is not None:
-        full_frame_time = exposure + controller.get_deadtime(exposure)
         await asyncio.gather(
-            driver.acquire_time.set(exposure, timeout=timeout),
-            driver.acquire_period.set(full_frame_time, timeout=timeout),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.image_mode.set(ImageMode.MULTIPLE),
         )
 
-
-async def start_acquiring_driver_and_ensure_status(
-    driver: ADBaseIO,
-    good_states: frozenset[DetectorState] = frozenset(DEFAULT_GOOD_STATES),
-    timeout: float = DEFAULT_TIMEOUT,
-) -> AsyncStatus:
-    """
-    Start acquiring driver, raising ValueError if the detector is in a bad state.
-
-    This sets driver.acquire to True, and waits for it to be True up to a timeout.
-    Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES, and otherwise
-    raises a ValueError.
-
-    Parameters
-    ----------
-    driver:
-        The driver to start acquiring. Must subclass ADBaseIO.
-    good_states:
-        set of states defined in DetectorState enum which are considered good states.
-    timeout:
-        How long to wait for driver.acquire to readback True (i.e. acquiring).
-
-    Returns
-    -------
-    AsyncStatus:
-        An AsyncStatus that can be awaited to set driver.acquire to True and perform
-        subsequent raising (if applicable) due to detector state.
-    """
-
-    status = await set_and_wait_for_value(
-        driver.acquire, True, timeout=timeout, wait_for_set_completion=False
-    )
-
-    async def complete_acquisition() -> None:
-        """NOTE: possible race condition here between the callback from
-        set_and_wait_for_value and the detector state updating."""
-        await status
-        state = await driver.detector_state.get_value()
-        if state not in good_states:
-            raise ValueError(
-                f"Final detector state {state.value} not in valid end "
-                f"states: {good_states}"
+    async def arm(self):
+        self._arm_status = await self.start_acquiring_driver_and_ensure_status()
+
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
+
+    async def disarm(self):
+        # We can't use caput callback as we already used it in arm() and we can't have
+        # 2 or they will deadlock
+        await stop_busy_record(self.driver.acquire, False, timeout=1)
+
+    async def set_exposure_time_and_acquire_period_if_supplied(
+        self,
+        exposure: float | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        """
+        Sets the exposure time if it is not None and the acquire period to the
+        exposure time plus the deadtime. This is expected behavior for most
+        AreaDetectors, but some may require more specialized handling.
+
+        Parameters
+        ----------
+        exposure:
+            Desired exposure time, this is a noop if it is None.
+        timeout:
+            How long to wait for the exposure time and acquire period to be set.
+        """
+        if exposure is not None:
+            full_frame_time = exposure + self.get_deadtime(exposure)
+            await asyncio.gather(
+                self.driver.acquire_time.set(exposure, timeout=timeout),
+                self.driver.acquire_period.set(full_frame_time, timeout=timeout),
             )
 
-    return AsyncStatus(complete_acquisition())
+    async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
+        """
+        Start acquiring driver, raising ValueError if the detector is in a bad state.
+
+        This sets driver.acquire to True, and waits for it to be True up to a timeout.
+        Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES,
+        and otherwise raises a ValueError.
+
+        Returns
+        -------
+        AsyncStatus:
+            An AsyncStatus that can be awaited to set driver.acquire to True and perform
+            subsequent raising (if applicable) due to detector state.
+        """
+
+        status = await set_and_wait_for_value(
+            self.driver.acquire,
+            True,
+            timeout=DEFAULT_TIMEOUT,
+            wait_for_set_completion=False,
+        )
+
+        async def complete_acquisition() -> None:
+            """NOTE: possible race condition here between the callback from
+            set_and_wait_for_value and the detector state updating."""
+            await status
+            state = await self.driver.detector_state.get_value()
+            if state not in self.good_states:
+                raise ValueError(
+                    f"Final detector state {state.value} not "
+                    "in valid end states: {self.good_states}"
+                )
+
+        return AsyncStatus(complete_acquisition())