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

ophyd_async/core/_utils.py

@@ -16,13 +16,38 @@ Callback = Callable[[T], None]
 DEFAULT_TIMEOUT = 10.0
 ErrorText = str | Mapping[str, Exception]
 
+logger = logging.getLogger("ophyd_async")
 
-class StrictEnum(str, Enum):
+
+class StrictEnumMeta(EnumMeta):
+    def __new__(metacls, *args, **kwargs):
+        ret = super().__new__(metacls, *args, **kwargs)
+        lowercase_names = [x.name for x in ret if not x.name.isupper()]  # type: ignore
+        if lowercase_names:
+            raise TypeError(f"Names {lowercase_names} should be uppercase")
+        return ret
+
+
+class StrictEnum(str, Enum, metaclass=StrictEnumMeta):
     """All members should exist in the Backend, and there will be no extras"""
 
 
-class SubsetEnumMeta(EnumMeta):
+class SubsetEnumMeta(StrictEnumMeta):
     def __call__(self, value, *args, **kwargs):  # type: ignore
+        """
+        Returns given value if it is a string and not a member of the enum.
+        If the value is not a string or is an enum member, default enum behavior
+        is applied. Type checking will complain if provided arbitrary string.
+
+        Returns:
+            Union[str, SubsetEnum]: If the value is a string and not a member of the
+            enum, the string is returned as is. Otherwise, the corresponding enum
+            member is returned.
+
+        Raises:
+            ValueError: If the value is not a string and cannot be converted to an enum
+            member.
+        """
         if isinstance(value, str) and not isinstance(value, self):
             return value
         return super().__call__(value, *args, **kwargs)
@@ -85,7 +110,7 @@ class NotConnected(Exception):
     def format_error_string(self, indent="") -> str:
         if not isinstance(self._errors, dict) and not isinstance(self._errors, str):
             raise RuntimeError(
-                f"Unexpected type `{type(self._errors)}` " "expected `str` or `dict`"
+                f"Unexpected type `{type(self._errors)}` expected `str` or `dict`"
             )
 
         if isinstance(self._errors, str):
@@ -105,7 +130,7 @@ class NotConnected(Exception):
     ) -> NotConnected:
         for name, exception in exceptions.items():
             if not isinstance(exception, NotConnected):
-                logging.exception(
+                logger.exception(
                     f"device `{name}` raised unexpected exception "
                     f"{type(exception).__name__}",
                     exc_info=exception,
@@ -180,7 +205,7 @@ def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
     if datatype and issubclass(datatype, Enum):
         if not issubclass(datatype, StrictEnum):
             raise TypeError(
-                f"{datatype} should inherit from .SubsetEnum "
+                f"{datatype} should inherit from ophyd_async.core.SubsetEnum "
                 "or ophyd_async.core.StrictEnum"
             )
         return datatype

ophyd_async/core/_yaml_settings.py

@@ -0,0 +1,64 @@
+import warnings
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+import yaml
+from pydantic import BaseModel
+
+from ._settings import SettingsProvider
+
+
+def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.Node:
+    return dumper.represent_sequence(
+        "tag:yaml.org,2002:seq", array.tolist(), flow_style=True
+    )
+
+
+def pydantic_model_abstraction_representer(
+    dumper: yaml.Dumper, model: BaseModel
+) -> yaml.Node:
+    return dumper.represent_data(model.model_dump(mode="python"))
+
+
+def enum_representer(dumper: yaml.Dumper, enum: Enum) -> yaml.Node:
+    return dumper.represent_data(enum.value)
+
+
+class YamlSettingsProvider(SettingsProvider):
+    def __init__(self, directory: Path | str):
+        self._directory = Path(directory)
+
+    def _file_path(self, name: str) -> Path:
+        return self._directory / (name + ".yaml")
+
+    async def store(self, name: str, data: dict[str, Any]):
+        yaml.add_representer(np.ndarray, ndarray_representer, Dumper=yaml.Dumper)
+        yaml.add_multi_representer(
+            BaseModel,
+            pydantic_model_abstraction_representer,
+            Dumper=yaml.Dumper,
+        )
+        yaml.add_multi_representer(Enum, enum_representer, Dumper=yaml.Dumper)
+        with open(self._file_path(name), "w") as file:
+            yaml.dump(data, file)
+
+    async def retrieve(self, name: str) -> dict[str, Any]:
+        with open(self._file_path(name)) as file:
+            data = yaml.full_load(file)
+        if isinstance(data, list):
+            warnings.warn(
+                DeprecationWarning(
+                    "Found old save file. Re-save your yaml settings file "
+                    f"{self._file_path(name)} using "
+                    "ophyd_async.plan_stubs.store_settings"
+                ),
+                stacklevel=2,
+            )
+            merge = {}
+            for d in data:
+                merge.update(d)
+            return merge
+        return data

ophyd_async/epics/adandor/__init__.py

@@ -0,0 +1,9 @@
+from ._andor import Andor2Detector
+from ._andor_controller import Andor2Controller
+from ._andor_io import Andor2DriverIO
+
+__all__ = [
+    "Andor2Detector",
+    "Andor2Controller",
+    "Andor2DriverIO",
+]

ophyd_async/epics/adandor/_andor.py

@@ -0,0 +1,45 @@
+from collections.abc import Sequence
+
+from ophyd_async.core import PathProvider
+from ophyd_async.core._signal import SignalR
+from ophyd_async.epics import adcore
+
+from ._andor_controller import Andor2Controller
+from ._andor_io import Andor2DriverIO
+
+
+class Andor2Detector(adcore.AreaDetector[Andor2Controller]):
+    """
+    Andor 2 area detector device (CCD detector 56fps with full chip readout).
+    Andor model:DU897_BV.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix="cam1:",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
+        config_sigs: Sequence[SignalR] = (),
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
+    ):
+        driver = Andor2DriverIO(prefix + drv_suffix)
+        controller = Andor2Controller(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
+
+        super().__init__(
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
+            name=name,
+            config_sigs=config_sigs,
+        )

ophyd_async/epics/adandor/_andor_controller.py

@@ -0,0 +1,49 @@
+import asyncio
+
+from ophyd_async.core import (
+    DetectorTrigger,
+    TriggerInfo,
+)
+from ophyd_async.epics import adcore
+
+from ._andor_io import Andor2DriverIO, Andor2TriggerMode
+
+_MIN_DEAD_TIME = 0.1
+_MAX_NUM_IMAGE = 999_999
+
+
+class Andor2Controller(adcore.ADBaseController[Andor2DriverIO]):
+    def __init__(
+        self,
+        driver: Andor2DriverIO,
+        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 _MIN_DEAD_TIME + (exposure or 0)
+
+    async def prepare(self, trigger_info: TriggerInfo):
+        await self.set_exposure_time_and_acquire_period_if_supplied(
+            trigger_info.livetime
+        )
+        await asyncio.gather(
+            self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
+            self.driver.num_images.set(
+                trigger_info.total_number_of_triggers or _MAX_NUM_IMAGE
+            ),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
+        )
+
+    def _get_trigger_mode(self, trigger: DetectorTrigger) -> Andor2TriggerMode:
+        supported_trigger_types = {
+            DetectorTrigger.INTERNAL: Andor2TriggerMode.INTERNAL,
+            DetectorTrigger.EDGE_TRIGGER: Andor2TriggerMode.EXT_TRIGGER,
+        }
+        if trigger not in supported_trigger_types:
+            raise ValueError(
+                f"{self.__class__.__name__} only supports the following trigger "
+                f"types: {supported_trigger_types} but was asked to "
+                f"use {trigger}"
+            )
+        return supported_trigger_types[trigger]

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