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

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -1,9 +1,9 @@
 import asyncio
+from enum import Enum
+from typing import TypeVar, get_args
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
     wait_for_value,
@@ -13,58 +13,83 @@ from ophyd_async.epics import adcore
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 
-class PilatusController(DetectorController):
+#: 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
+
+
+PilatusControllerT = TypeVar("PilatusControllerT", bound="PilatusController")
+
+
+class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
     _supported_trigger_types = {
-        DetectorTrigger.internal: PilatusTriggerMode.internal,
-        DetectorTrigger.constant_gate: PilatusTriggerMode.ext_enable,
-        DetectorTrigger.variable_gate: PilatusTriggerMode.ext_enable,
+        DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
+        DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
+        DetectorTrigger.VARIABLE_GATE: PilatusTriggerMode.EXT_ENABLE,
     }
 
     def __init__(
         self,
         driver: PilatusDriverIO,
-        readout_time: float,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        readout_time: float = PilatusReadoutTime.PILATUS3,
     ) -> None:
-        self._drv = driver
+        super().__init__(driver, good_states=good_states)
         self._readout_time = readout_time
-        self._arm_status: AsyncStatus | None = None
+
+    @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
 
     async def prepare(self, trigger_info: TriggerInfo):
         if trigger_info.livetime is not None:
-            await adcore.set_exposure_time_and_acquire_period_if_supplied(
-                self, self._drv, trigger_info.livetime
+            await self.set_exposure_time_and_acquire_period_if_supplied(
+                trigger_info.livetime
             )
         await asyncio.gather(
-            self._drv.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
-            self._drv.num_images.set(
+            self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
+            self.driver.num_images.set(
                 999_999
                 if trigger_info.total_number_of_triggers == 0
                 else trigger_info.total_number_of_triggers
             ),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
 
     async def arm(self):
         # Standard arm the detector and wait for the acquire PV to be True
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self._drv
-        )
+        self._arm_status = await self.start_acquiring_driver_and_ensure_status()
+
         # The pilatus has an additional PV that goes True when the camserver
         # is actually ready. Should wait for that too or we risk dropping
         # a frame
         await wait_for_value(
-            self._drv.armed,
+            self.driver.armed,
             True,
             timeout=DEFAULT_TIMEOUT,
         )
 
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
     @classmethod
     def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:
         if trigger not in cls._supported_trigger_types.keys():
@@ -74,6 +99,3 @@ class PilatusController(DetectorController):
                 f"use {trigger}"
             )
         return cls._supported_trigger_types[trigger]
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -4,11 +4,11 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv
 
 
 class PilatusTriggerMode(StrictEnum):
-    internal = "Internal"
-    ext_enable = "Ext. Enable"
-    ext_trigger = "Ext. Trigger"
-    mult_trigger = "Mult. Trigger"
-    alignment = "Alignment"
+    INTERNAL = "Internal"
+    EXT_ENABLE = "Ext. Enable"
+    EXT_TRIGGER = "Ext. Trigger"
+    MULT_TRIGGER = "Mult. Trigger"
+    ALIGNMENT = "Alignment"
 
 
 class PilatusDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adsimdetector/__init__.py

@@ -1,7 +1,7 @@
-from ._sim import SimDetector
-from ._sim_controller import SimController
+from ._sim import SimController, SimDetector, SimDriverIO
 
 __all__ = [
-    "SimDetector",
+    "SimDriverIO",
     "SimController",
+    "SimDetector",
 ]

ophyd_async/epics/adsimdetector/_sim.py

@@ -1,35 +1,51 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, SignalR, StandardDetector
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
-from ._sim_controller import SimController
 
+class SimDriverIO(adcore.ADBaseIO): ...
 
-class SimDetector(StandardDetector):
-    _controller: SimController
-    _writer: adcore.ADHDFWriter
 
+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
+
+
+class SimDetector(adcore.AreaDetector[SimController]):
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
         drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name: str = "",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name="",
         config_sigs: Sequence[SignalR] = (),
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
     ):
-        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = SimDriverIO(prefix + drv_suffix)
+        controller = SimController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            SimController(self.drv),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_period, self.drv.acquire_time, *config_sigs),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )

ophyd_async/epics/advimba/_vimba.py

@@ -1,43 +1,43 @@
-from bluesky.protocols import HasHints, Hints
+from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._vimba_controller import VimbaController
 from ._vimba_io import VimbaDriverIO
 
 
-class VimbaDetector(StandardDetector, HasHints):
+class VimbaDetector(adcore.AreaDetector[VimbaController]):
     """
     Ophyd-async implementation of an ADVimba Detector.
     """
 
-    _controller: VimbaController
-    _writer: adcore.ADHDFWriter
-
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        drv_suffix: str = "cam1:",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = VimbaDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = VimbaDriverIO(prefix + drv_suffix)
+        controller = VimbaController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            VimbaController(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/advimba/_vimba_controller.py

@@ -1,8 +1,6 @@
 import asyncio
 
 from ophyd_async.core import (
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
 )
@@ -11,56 +9,44 @@ from ophyd_async.epics import adcore
 from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
 
 TRIGGER_MODE = {
-    DetectorTrigger.internal: VimbaOnOff.off,
-    DetectorTrigger.constant_gate: VimbaOnOff.on,
-    DetectorTrigger.variable_gate: VimbaOnOff.on,
-    DetectorTrigger.edge_trigger: VimbaOnOff.on,
+    DetectorTrigger.INTERNAL: VimbaOnOff.OFF,
+    DetectorTrigger.CONSTANT_GATE: VimbaOnOff.ON,
+    DetectorTrigger.VARIABLE_GATE: VimbaOnOff.ON,
+    DetectorTrigger.EDGE_TRIGGER: VimbaOnOff.ON,
 }
 
 EXPOSE_OUT_MODE = {
-    DetectorTrigger.internal: VimbaExposeOutMode.timed,
-    DetectorTrigger.constant_gate: VimbaExposeOutMode.trigger_width,
-    DetectorTrigger.variable_gate: VimbaExposeOutMode.trigger_width,
-    DetectorTrigger.edge_trigger: VimbaExposeOutMode.timed,
+    DetectorTrigger.INTERNAL: VimbaExposeOutMode.TIMED,
+    DetectorTrigger.CONSTANT_GATE: VimbaExposeOutMode.TRIGGER_WIDTH,
+    DetectorTrigger.VARIABLE_GATE: VimbaExposeOutMode.TRIGGER_WIDTH,
+    DetectorTrigger.EDGE_TRIGGER: VimbaExposeOutMode.TIMED,
 }
 
 
-class VimbaController(DetectorController):
+class VimbaController(adcore.ADBaseController[VimbaDriverIO]):
     def __init__(
         self,
         driver: VimbaDriverIO,
+        good_states: frozenset[adcore.DetectorState] = 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(TRIGGER_MODE[trigger_info.trigger]),
-            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[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(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),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
-            DetectorTrigger.variable_gate,
-            DetectorTrigger.constant_gate,
+            DetectorTrigger.VARIABLE_GATE,
+            DetectorTrigger.CONSTANT_GATE,
         ]:
-            await self._drv.acquire_time.set(trigger_info.livetime)
-        if trigger_info.trigger != DetectorTrigger.internal:
-            self._drv.trigger_source.set(VimbaTriggerSource.line1)
+            await self.driver.acquire_time.set(trigger_info.livetime)
+        if trigger_info.trigger != DetectorTrigger.INTERNAL:
+            self.driver.trigger_source.set(VimbaTriggerSource.LINE1)
         else:
-            self._drv.trigger_source.set(VimbaTriggerSource.freerun)
-
-    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)
+            self.driver.trigger_source.set(VimbaTriggerSource.FREERUN)

ophyd_async/epics/advimba/_vimba_io.py

@@ -4,44 +4,44 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class VimbaPixelFormat(StrictEnum):
-    internal = "Mono8"
-    ext_enable = "Mono12"
-    ext_trigger = "Ext. Trigger"
-    mult_trigger = "Mult. Trigger"
-    alignment = "Alignment"
+    INTERNAL = "Mono8"
+    EXT_ENABLE = "Mono12"
+    EXT_TRIGGER = "Ext. Trigger"
+    MULT_TRIGGER = "Mult. Trigger"
+    ALIGNMENT = "Alignment"
 
 
 class VimbaConvertFormat(StrictEnum):
-    none = "None"
-    mono8 = "Mono8"
-    mono16 = "Mono16"
-    rgb8 = "RGB8"
-    rgb16 = "RGB16"
+    NONE = "None"
+    MONO8 = "Mono8"
+    MONO16 = "Mono16"
+    RGB8 = "RGB8"
+    RGB16 = "RGB16"
 
 
 class VimbaTriggerSource(StrictEnum):
-    freerun = "Freerun"
-    line1 = "Line1"
-    line2 = "Line2"
-    fixed_rate = "FixedRate"
-    software = "Software"
-    action0 = "Action0"
-    action1 = "Action1"
+    FREERUN = "Freerun"
+    LINE1 = "Line1"
+    LINE2 = "Line2"
+    FIXED_RATE = "FixedRate"
+    SOFTWARE = "Software"
+    ACTION0 = "Action0"
+    ACTION1 = "Action1"
 
 
 class VimbaOverlap(StrictEnum):
-    off = "Off"
-    prev_frame = "PreviousFrame"
+    OFF = "Off"
+    PREV_FRAME = "PreviousFrame"
 
 
 class VimbaOnOff(StrictEnum):
-    on = "On"
-    off = "Off"
+    ON = "On"
+    OFF = "Off"
 
 
 class VimbaExposeOutMode(StrictEnum):
-    timed = "Timed"  # Use ExposureTime PV
-    trigger_width = "TriggerWidth"  # Expose for length of high signal
+    TIMED = "Timed"  # Use ExposureTime PV
+    TRIGGER_WIDTH = "TriggerWidth"  # Expose for length of high signal
 
 
 class VimbaDriverIO(adcore.ADBaseIO):

ophyd_async/epics/core/_aioca.py

@@ -35,12 +35,14 @@ from ophyd_async.core import (
 
 from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
+logger = logging.getLogger("ophyd_async")
+
 
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
     def get_limits(limit: str) -> LimitsRange | None:
         low = getattr(value, f"lower_{limit}_limit", nan)
         high = getattr(value, f"upper_{limit}_limit", nan)
-        if not (isnan(low) and isnan(high)):
+        if not (isnan(low) and isnan(high)) and not high == low == 0:
             return LimitsRange(
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
@@ -59,14 +61,20 @@ def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
 
 
 def _metadata_from_augmented_value(
-    value: AugmentedValue, metadata: SignalMetadata
+    datatype: type[SignalDatatypeT] | None,
+    value: AugmentedValue,
+    metadata: SignalMetadata,
 ) -> SignalMetadata:
     metadata = metadata.copy()
-    if hasattr(value, "units"):
+    if hasattr(value, "units") and datatype not in (str, bool):
         metadata["units"] = value.units
-    if hasattr(value, "precision") and not isnan(value.precision):
+    if (
+        hasattr(value, "precision")
+        and not isnan(value.precision)
+        and datatype is not int
+    ):
         metadata["precision"] = value.precision
-    if limits := _limits_from_augmented_value(value):
+    if (limits := _limits_from_augmented_value(value)) and datatype is not bool:
         metadata["limits"] = limits
     return metadata
 
@@ -100,6 +108,11 @@ class DisconnectedCaConverter(CaConverter):
         raise NotImplementedError("No PV has been set as connect() has not been called")
 
 
+class CaIntConverter(CaConverter[int]):
+    def value(self, value: AugmentedValue) -> int:
+        return int(value)  # type: ignore
+
+
 class CaArrayConverter(CaConverter[np.ndarray]):
     def value(self, value: AugmentedValue) -> np.ndarray:
         # A less expensive conversion
@@ -202,7 +215,7 @@ def make_converter(
         and get_unique({k: v.precision for k, v in values.items()}, "precision") == 0
     ):
         # Allow int signals to represent float records when prec is 0
-        return CaConverter(int, pv_dbr)
+        return CaIntConverter(int, pv_dbr)
     elif datatype in (None, inferred_datatype):
         # If datatype matches what we are given then allow it and use inferred converter
         return converter_cls(inferred_datatype, pv_dbr)
@@ -247,7 +260,7 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
                 pv, format=FORMAT_CTRL, timeout=timeout
             )
         except CANothing as exc:
-            logging.debug(f"signal ca://{pv} timed out")
+            logger.debug(f"signal ca://{pv} timed out")
             raise NotConnected(f"ca://{pv}") from exc
 
     async def connect(self, timeout: float):
@@ -280,17 +293,33 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             write_value = self.initial_values[self.write_pv]
         else:
             write_value = self.converter.write_value(value)
-        await caput(
-            self.write_pv,
-            write_value,
-            datatype=self.converter.write_dbr,
-            wait=wait,
-            timeout=None,
-        )
+        try:
+            await caput(
+                self.write_pv,
+                write_value,
+                datatype=self.converter.write_dbr,
+                wait=wait,
+                timeout=None,
+            )
+        except CANothing as exc:
+            # If we ran into a write error, check to see if there is a list
+            # of valid choices, and if the value we tried to write is in that list.
+            valid_choices = self.converter.metadata.get("choices")
+            if valid_choices:
+                if value not in valid_choices:
+                    msg = (
+                        f"{value} is not a valid choice for {self.write_pv}, "
+                        f"valid choices: {self.converter.metadata.get('choices')}"
+                    )
+                    raise ValueError(msg) from exc
+                raise
+            raise
 
     async def get_datakey(self, source: str) -> DataKey:
         value = await self._caget(self.read_pv, FORMAT_CTRL)
-        metadata = _metadata_from_augmented_value(value, self.converter.metadata)
+        metadata = _metadata_from_augmented_value(
+            self.datatype, value, self.converter.metadata
+        )
         return make_datakey(
             self.converter.datatype, self.converter.value(value), source, metadata
         )
@@ -308,16 +337,18 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         return self.converter.value(value)
 
     def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
+        if callback and self.subscription:
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.subscription:
+            self.subscription.close()
+            self.subscription = None
+
         if callback:
-            assert (
-                not self.subscription
-            ), "Cannot set a callback when one is already set"
             self.subscription = camonitor(
                 self.read_pv,
                 lambda v: callback(self._make_reading(v)),
                 datatype=self.converter.read_dbr,
                 format=FORMAT_TIME,
             )
-        elif self.subscription:
-            self.subscription.close()
-            self.subscription = None