ophyd-async 0.3a2__py3-none-any.whl → 0.3a4__py3-none-any.whl

ophyd_async/core/standard_readable.py

@@ -1,16 +1,34 @@
-from typing import Dict, Sequence, Tuple
+import warnings
+from contextlib import contextmanager
+from typing import (
+    Callable,
+    Dict,
+    Generator,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+)
 
-from bluesky.protocols import Descriptor, Reading, Stageable
+from bluesky.protocols import DataKey, HasHints, Hints, Reading
 
-from ophyd_async.protocols import AsyncConfigurable, AsyncReadable
+from ophyd_async.protocols import AsyncConfigurable, AsyncReadable, AsyncStageable
 
 from .async_status import AsyncStatus
-from .device import Device
+from .device import Device, DeviceVector
 from .signal import SignalR
 from .utils import merge_gathered_dicts
 
+ReadableChild = Union[AsyncReadable, AsyncConfigurable, AsyncStageable, HasHints]
+ReadableChildWrapper = Union[
+    Callable[[ReadableChild], ReadableChild], Type["ConfigSignal"], Type["HintedSignal"]
+]
 
-class StandardReadable(Device, AsyncReadable, AsyncConfigurable, Stageable):
+
+class StandardReadable(
+    Device, AsyncReadable, AsyncConfigurable, AsyncStageable, HasHints
+):
     """Device that owns its children and provides useful default behavior.
 
     - When its name is set it renames child Devices
@@ -18,9 +36,12 @@ class StandardReadable(Device, AsyncReadable, AsyncConfigurable, Stageable):
     - These signals will be subscribed for read() between stage() and unstage()
     """
 
-    _read_signals: Tuple[SignalR, ...] = ()
-    _configuration_signals: Tuple[SignalR, ...] = ()
-    _read_uncached_signals: Tuple[SignalR, ...] = ()
+    # These must be immutable types to avoid accidental sharing between
+    # different instances of the class
+    _readables: Tuple[AsyncReadable, ...] = ()
+    _configurables: Tuple[AsyncConfigurable, ...] = ()
+    _stageables: Tuple[AsyncStageable, ...] = ()
+    _has_hints: Tuple[HasHints, ...] = ()
 
     def set_readable_signals(
         self,
@@ -38,37 +59,203 @@ class StandardReadable(Device, AsyncReadable, AsyncConfigurable, Stageable):
         read_uncached:
             Signals to make up :meth:`~StandardReadable.read` that won't be cached
         """
-        self._read_signals = tuple(read)
-        self._configuration_signals = tuple(config)
-        self._read_uncached_signals = tuple(read_uncached)
+        warnings.warn(
+            DeprecationWarning(
+                "Migrate to `add_children_as_readables` context manager or "
+                "`add_readables` method"
+            )
+        )
+        self.add_readables(read, wrapper=HintedSignal)
+        self.add_readables(config, wrapper=ConfigSignal)
+        self.add_readables(read_uncached, wrapper=HintedSignal.uncached)
 
     @AsyncStatus.wrap
     async def stage(self) -> None:
-        for sig in self._read_signals + self._configuration_signals:
+        for sig in self._stageables:
             await sig.stage().task
 
     @AsyncStatus.wrap
     async def unstage(self) -> None:
-        for sig in self._read_signals + self._configuration_signals:
+        for sig in self._stageables:
             await sig.unstage().task
 
-    async def describe_configuration(self) -> Dict[str, Descriptor]:
+    async def describe_configuration(self) -> Dict[str, DataKey]:
         return await merge_gathered_dicts(
-            [sig.describe() for sig in self._configuration_signals]
+            [sig.describe_configuration() for sig in self._configurables]
         )
 
     async def read_configuration(self) -> Dict[str, Reading]:
         return await merge_gathered_dicts(
-            [sig.read() for sig in self._configuration_signals]
+            [sig.read_configuration() for sig in self._configurables]
         )
 
-    async def describe(self) -> Dict[str, Descriptor]:
-        return await merge_gathered_dicts(
-            [sig.describe() for sig in self._read_signals + self._read_uncached_signals]
-        )
+    async def describe(self) -> Dict[str, DataKey]:
+        return await merge_gathered_dicts([sig.describe() for sig in self._readables])
 
     async def read(self) -> Dict[str, Reading]:
-        return await merge_gathered_dicts(
-            [sig.read() for sig in self._read_signals]
-            + [sig.read(cached=False) for sig in self._read_uncached_signals]
-        )
+        return await merge_gathered_dicts([sig.read() for sig in self._readables])
+
+    @property
+    def hints(self) -> Hints:
+        hints: Hints = {}
+        for new_hint in self._has_hints:
+            # Merge the existing and new hints, based on the type of the value.
+            # This avoids default dict merge behaviour that overrides the values;
+            # we want to combine them when they are Sequences, and ensure they are
+            # identical when string values.
+            for key, value in new_hint.hints.items():
+                if isinstance(value, str):
+                    if key in hints:
+                        assert (
+                            hints[key] == value  # type: ignore[literal-required]
+                        ), f"Hints key {key} value may not be overridden"
+                    else:
+                        hints[key] = value  # type: ignore[literal-required]
+                elif isinstance(value, Sequence):
+                    if key in hints:
+                        for new_val in value:
+                            assert (
+                                new_val not in hints[key]  # type: ignore[literal-required]
+                            ), f"Hint {key} {new_val} overrides existing hint"
+                        hints[key] = (  # type: ignore[literal-required]
+                            hints[key] + value  # type: ignore[literal-required]
+                        )
+                    else:
+                        hints[key] = value  # type: ignore[literal-required]
+                else:
+                    raise TypeError(
+                        f"{new_hint.name}: Unknown type for value '{value}' "
+                        f" for key '{key}'"
+                    )
+
+        return hints
+
+    @contextmanager
+    def add_children_as_readables(
+        self,
+        wrapper: Optional[ReadableChildWrapper] = None,
+    ) -> Generator[None, None, None]:
+        """Context manager to wrap adding Devices
+
+        Add Devices to this class instance inside the Context Manager to automatically
+        add them to the correct fields, based on the Device's interfaces.
+
+        The provided wrapper class will be applied to all Devices and can be used to
+        specify their behaviour.
+
+        Parameters
+        ----------
+        wrapper:
+            Wrapper class to apply to all Devices created inside the context manager.
+
+        See Also
+        --------
+        :func:`~StandardReadable.add_readables`
+        :class:`ConfigSignal`
+        :class:`HintedSignal`
+        :meth:`HintedSignal.uncached`
+        """
+
+        dict_copy = self.__dict__.copy()
+
+        yield
+
+        # Set symmetric difference operator gives all newly added keys
+        new_keys = dict_copy.keys() ^ self.__dict__.keys()
+        new_values = [self.__dict__[key] for key in new_keys]
+
+        flattened_values = []
+        for value in new_values:
+            if isinstance(value, DeviceVector):
+                children = value.children()
+                flattened_values.extend([x[1] for x in children])
+            else:
+                flattened_values.append(value)
+
+        new_devices = list(filter(lambda x: isinstance(x, Device), flattened_values))
+        self.add_readables(new_devices, wrapper)
+
+    def add_readables(
+        self,
+        devices: Sequence[Device],
+        wrapper: Optional[ReadableChildWrapper] = None,
+    ) -> None:
+        """Add the given devices to the lists of known Devices
+
+        Add the provided Devices to the relevant fields, based on the Signal's
+        interfaces.
+
+        The provided wrapper class will be applied to all Devices and can be used to
+        specify their behaviour.
+
+        Parameters
+        ----------
+        devices:
+            The devices to be added
+        wrapper:
+            Wrapper class to apply to all Devices created inside the context manager.
+
+        See Also
+        --------
+        :func:`~StandardReadable.add_children_as_readables`
+        :class:`ConfigSignal`
+        :class:`HintedSignal`
+        :meth:`HintedSignal.uncached`
+        """
+
+        for readable in devices:
+            obj = readable
+            if wrapper:
+                obj = wrapper(readable)
+
+            if isinstance(obj, AsyncReadable):
+                self._readables += (obj,)
+
+            if isinstance(obj, AsyncConfigurable):
+                self._configurables += (obj,)
+
+            if isinstance(obj, AsyncStageable):
+                self._stageables += (obj,)
+
+            if isinstance(obj, HasHints):
+                self._has_hints += (obj,)
+
+
+class ConfigSignal(AsyncConfigurable):
+    def __init__(self, signal: ReadableChild) -> None:
+        assert isinstance(signal, SignalR), f"Expected signal, got {signal}"
+        self.signal = signal
+
+    async def read_configuration(self) -> Dict[str, Reading]:
+        return await self.signal.read()
+
+    async def describe_configuration(self) -> Dict[str, DataKey]:
+        return await self.signal.describe()
+
+
+class HintedSignal(HasHints, AsyncReadable):
+    def __init__(self, signal: ReadableChild, allow_cache: bool = True) -> None:
+        assert isinstance(signal, SignalR), f"Expected signal, got {signal}"
+        self.signal = signal
+        self.cached = None if allow_cache else allow_cache
+        if allow_cache:
+            self.stage = signal.stage
+            self.unstage = signal.unstage
+
+    async def read(self) -> Dict[str, Reading]:
+        return await self.signal.read(cached=self.cached)
+
+    async def describe(self) -> Dict[str, DataKey]:
+        return await self.signal.describe()
+
+    @property
+    def name(self) -> str:
+        return self.signal.name
+
+    @property
+    def hints(self) -> Hints:
+        return {"fields": [self.signal.name]}
+
+    @classmethod
+    def uncached(cls, signal: ReadableChild) -> "HintedSignal":
+        return cls(signal, allow_cache=False)

ophyd_async/epics/_backend/_aioca.py

@@ -15,7 +15,7 @@ from aioca import (
     caput,
 )
 from aioca.types import AugmentedValue, Dbr, Format
-from bluesky.protocols import Descriptor, Dtype, Reading
+from bluesky.protocols import DataKey, Dtype, Reading
 from epicscorelibs.ca import dbr
 
 from ophyd_async.core import (
@@ -28,7 +28,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import get_supported_enum_class
+from .common import get_supported_values
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
@@ -58,7 +58,7 @@ class CaConverter:
             "alarm_severity": -1 if value.severity > 2 else value.severity,
         }
 
-    def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
+    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
         return {"source": source, "dtype": dbr_to_dtype[value.datatype], "shape": []}
 
 
@@ -73,13 +73,13 @@ class CaLongStrConverter(CaConverter):
 
 
 class CaArrayConverter(CaConverter):
-    def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
+    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
         return {"source": source, "dtype": "array", "shape": [len(value)]}
 
 
 @dataclass
 class CaEnumConverter(CaConverter):
-    enum_class: Type[Enum]
+    choices: dict[str, str]
 
     def write_value(self, value: Union[Enum, str]):
         if isinstance(value, Enum):
@@ -88,11 +88,15 @@ class CaEnumConverter(CaConverter):
             return value
 
     def value(self, value: AugmentedValue):
-        return self.enum_class(value)
+        return self.choices[value]
 
-    def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
-        choices = [e.value for e in self.enum_class]
-        return {"source": source, "dtype": "string", "shape": [], "choices": choices}
+    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
+        return {
+            "source": source,
+            "dtype": "string",
+            "shape": [],
+            "choices": list(self.choices),
+        }
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -138,8 +142,8 @@ def make_converter(
         pv_choices = get_unique(
             {k: tuple(v.enums) for k, v in values.items()}, "choices"
         )
-        enum_class = get_supported_enum_class(pv, datatype, pv_choices)
-        return CaEnumConverter(dbr.DBR_STRING, None, enum_class)
+        supported_values = get_supported_values(pv, datatype, pv_choices)
+        return CaEnumConverter(dbr.DBR_STRING, None, supported_values)
     else:
         value = list(values.values())[0]
         # Done the dbr check, so enough to check one of the values
@@ -218,9 +222,9 @@ class CaSignalBackend(SignalBackend[T]):
             timeout=None,
         )
 
-    async def get_descriptor(self, source: str) -> Descriptor:
+    async def get_datakey(self, source: str) -> DataKey:
         value = await self._caget(FORMAT_CTRL)
-        return self.converter.descriptor(source, value)
+        return self.converter.get_datakey(source, value)
 
     async def get_reading(self) -> Reading:
         value = await self._caget(FORMAT_TIME)

ophyd_async/epics/_backend/_p4p.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, List, Optional, Sequence, Type, Union
 
-from bluesky.protocols import Descriptor, Dtype, Reading
+from bluesky.protocols import DataKey, Dtype, Reading
 from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 
@@ -20,7 +20,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import get_supported_enum_class
+from .common import get_supported_values
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {
@@ -55,7 +55,7 @@ class PvaConverter:
             "alarm_severity": -1 if sv > 2 else sv,
         }
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         dtype = specifier_to_dtype[value.type().aspy("value")]
         return {"source": source, "dtype": dtype, "shape": []}
 
@@ -73,7 +73,7 @@ class PvaConverter:
 
 
 class PvaArrayConverter(PvaConverter):
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         return {"source": source, "dtype": "array", "shape": [len(value["value"])]}
 
 
@@ -96,7 +96,7 @@ class PvaNDArrayConverter(PvaConverter):
         dims = self._get_dimensions(value)
         return value["value"].reshape(dims)
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         dims = self._get_dimensions(value)
         return {"source": source, "dtype": "array", "shape": dims}
 
@@ -109,7 +109,8 @@ class PvaNDArrayConverter(PvaConverter):
 
 @dataclass
 class PvaEnumConverter(PvaConverter):
-    enum_class: Type[Enum]
+    def __init__(self, choices: dict[str, str]):
+        self.choices = tuple(choices.values())
 
     def write_value(self, value: Union[Enum, str]):
         if isinstance(value, Enum):
@@ -118,18 +119,22 @@ class PvaEnumConverter(PvaConverter):
             return value
 
     def value(self, value):
-        return list(self.enum_class)[value["value"]["index"]]
+        return self.choices[value["value"]["index"]]
 
-    def descriptor(self, source: str, value) -> Descriptor:
-        choices = [e.value for e in self.enum_class]
-        return {"source": source, "dtype": "string", "shape": [], "choices": choices}
+    def get_datakey(self, source: str, value) -> DataKey:
+        return {
+            "source": source,
+            "dtype": "string",
+            "shape": [],
+            "choices": list(self.choices),
+        }
 
 
 class PvaEnumBoolConverter(PvaConverter):
     def value(self, value):
         return value["value"]["index"]
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         return {"source": source, "dtype": "integer", "shape": []}
 
 
@@ -137,7 +142,7 @@ class PvaTableConverter(PvaConverter):
     def value(self, value):
         return value["value"].todict()
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         # This is wrong, but defer until we know how to actually describe a table
         return {"source": source, "dtype": "object", "shape": []}  # type: ignore
 
@@ -152,7 +157,7 @@ class PvaDictConverter(PvaConverter):
     def value(self, value: Value):
         return value.todict()
 
-    def descriptor(self, source: str, value) -> Descriptor:
+    def get_datakey(self, source: str, value) -> DataKey:
         raise NotImplementedError("Describing Dict signals not currently supported")
 
     def metadata_fields(self) -> List[str]:
@@ -214,9 +219,15 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
         pv_choices = get_unique(
             {k: tuple(v["value"]["choices"]) for k, v in values.items()}, "choices"
         )
-        return PvaEnumConverter(get_supported_enum_class(pv, datatype, pv_choices))
+        return PvaEnumConverter(get_supported_values(pv, datatype, pv_choices))
     elif "NTScalar" in typeid:
-        if datatype and not issubclass(typ, datatype):
+        if (
+            datatype
+            and not issubclass(typ, datatype)
+            and not (
+                typ is float and datatype is int
+            )  # Allow float -> int since prec can be 0
+        ):
             raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
         return PvaConverter()
     elif "NTTable" in typeid:
@@ -238,7 +249,6 @@ class PvaSignalBackend(SignalBackend[T]):
         self.converter: PvaConverter = DisconnectedPvaConverter()
         self.subscription: Optional[Subscription] = None
 
-    @property
     def source(self, name: str):
         return f"pva://{self.read_pv}"
 
@@ -293,9 +303,9 @@ class PvaSignalBackend(SignalBackend[T]):
             )
             raise NotConnected(f"pva://{self.write_pv}") from exc
 
-    async def get_descriptor(self, source: str) -> Descriptor:
+    async def get_datakey(self, source: str) -> DataKey:
         value = await self.ctxt.get(self.read_pv)
-        return self.converter.descriptor(source, value)
+        return self.converter.get_datakey(source, value)
 
     def _pva_request_string(self, fields: List[str]) -> str:
         """

ophyd_async/epics/_backend/common.py

@@ -1,25 +1,25 @@
 from enum import Enum
-from typing import Any, Optional, Tuple, Type
+from typing import Dict, Optional, Tuple, Type
 
 
-def get_supported_enum_class(
+def get_supported_values(
     pv: str,
-    datatype: Optional[Type[Enum]],
-    pv_choices: Tuple[Any, ...],
-) -> Type[Enum]:
+    datatype: Optional[Type[str]],
+    pv_choices: Tuple[str, ...],
+) -> Dict[str, str]:
     if not datatype:
-        return Enum("GeneratedChoices", {x or "_": x for x in pv_choices}, type=str)  # type: ignore
+        return {x: x or "_" for x in pv_choices}
 
-    if not issubclass(datatype, Enum):
-        raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
     if not issubclass(datatype, str):
-        raise TypeError(f"{pv} has type Enum but doesn't inherit from String")
-    choices = tuple(v.value for v in datatype)
-    if set(choices) != set(pv_choices):
-        raise TypeError(
-            (
-                f"{pv} has choices {pv_choices}, "
-                f"which do not match {datatype}, which has {choices}"
+        raise TypeError(f"{pv} is type Enum but doesn't inherit from String")
+    if issubclass(datatype, Enum):
+        choices = tuple(v.value for v in datatype)
+        if set(choices) != set(pv_choices):
+            raise TypeError(
+                (
+                    f"{pv} has choices {pv_choices}, "
+                    f"which do not match {datatype}, which has {choices}"
+                )
             )
-        )
-    return datatype
+        return {x: datatype(x) for x in pv_choices}
+    return {x: x for x in pv_choices}

ophyd_async/epics/areadetector/__init__.py

@@ -1,4 +1,5 @@
 from .aravis import AravisDetector
+from .kinetix import KinetixDetector
 from .pilatus import PilatusDetector
 from .single_trigger_det import SingleTriggerDet
 from .utils import (
@@ -6,17 +7,16 @@ from .utils import (
     ImageMode,
     NDAttributeDataType,
     NDAttributesXML,
-    ad_r,
-    ad_rw,
 )
+from .vimba import VimbaDetector
 
 __all__ = [
     "AravisDetector",
+    "KinetixDetector",
+    "VimbaDetector",
     "SingleTriggerDet",
     "FileWriteMode",
     "ImageMode",
-    "ad_r",
-    "ad_rw",
     "NDAttributeDataType",
     "NDAttributesXML",
     "PilatusDetector",

ophyd_async/epics/areadetector/aravis.py

@@ -23,16 +23,15 @@ class AravisDetector(StandardDetector, HasHints):
 
     def __init__(
         self,
-        name: str,
+        prefix: str,
         directory_provider: DirectoryProvider,
-        driver: AravisDriver,
-        hdf: NDFileHDF,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
         gpio_number: AravisController.GPIO_NUMBER = 1,
-        **scalar_sigs: str,
     ):
-        # Must be child of Detector to pick up connect()
-        self.drv = driver
-        self.hdf = hdf
+        self.drv = AravisDriver(prefix + drv_suffix)
+        self.hdf = NDFileHDF(prefix + hdf_suffix)
 
         super().__init__(
             AravisController(self.drv, gpio_number=gpio_number),
@@ -41,9 +40,8 @@ class AravisDetector(StandardDetector, HasHints):
                 directory_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
-                **scalar_sigs,
             ),
-            config_sigs=(self.drv.acquire_time, self.drv.acquire),
+            config_sigs=(self.drv.acquire_time,),
             name=name,
         )
 

ophyd_async/epics/areadetector/controllers/__init__.py

@@ -1,4 +1,5 @@
 from .ad_sim_controller import ADSimController
+from .aravis_controller import AravisController
 from .pilatus_controller import PilatusController
 
-__all__ = ["PilatusController", "ADSimController"]
+__all__ = ["PilatusController", "ADSimController", "AravisController"]

ophyd_async/epics/areadetector/controllers/kinetix_controller.py

@@ -0,0 +1,49 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.epics.areadetector.drivers.ad_base import (
+    start_acquiring_driver_and_ensure_status,
+)
+
+from ..drivers.kinetix_driver import KinetixDriver, KinetixTriggerMode
+from ..utils import ImageMode, stop_busy_record
+
+KINETIX_TRIGGER_MODE_MAP = {
+    DetectorTrigger.internal: KinetixTriggerMode.internal,
+    DetectorTrigger.constant_gate: KinetixTriggerMode.gate,
+    DetectorTrigger.variable_gate: KinetixTriggerMode.gate,
+    DetectorTrigger.edge_trigger: KinetixTriggerMode.edge,
+}
+
+
+class KinetixController(DetectorControl):
+    def __init__(
+        self,
+        driver: KinetixDriver,
+    ) -> None:
+        self._drv = driver
+
+    def get_deadtime(self, exposure: float) -> float:
+        return 0.001
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        await asyncio.gather(
+            self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger]),
+            self._drv.num_images.set(num),
+            self._drv.image_mode.set(ImageMode.multiple),
+        )
+        if exposure is not None and trigger not in [
+            DetectorTrigger.variable_gate,
+            DetectorTrigger.constant_gate,
+        ]:
+            await self._drv.acquire_time.set(exposure)
+        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+    async def disarm(self):
+        await stop_busy_record(self._drv.acquire, False, timeout=1)