ophyd-async 0.1.0__py3-none-any.whl → 0.3a1__py3-none-any.whl

ophyd_async/core/utils.py

@@ -1,5 +1,18 @@
+from __future__ import annotations
+
 import asyncio
-from typing import Awaitable, Callable, Dict, Iterable, List, Optional, Type, TypeVar
+import logging
+from typing import (
+    Awaitable,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
 
 import numpy as np
 from bluesky.protocols import Reading
@@ -11,46 +24,79 @@ Callback = Callable[[T], None]
 #: monitor updates
 ReadingValueCallback = Callable[[Reading, T], None]
 DEFAULT_TIMEOUT = 10.0
+ErrorText = Union[str, Dict[str, Exception]]
 
 
 class NotConnected(Exception):
     """Exception to be raised if a `Device.connect` is cancelled"""
 
-    def __init__(self, *lines: str):
-        self.lines = list(lines)
+    _indent_width = "    "
+
+    def __init__(self, errors: ErrorText):
+        """
+        NotConnected holds a mapping of device/signal names to
+        errors.
+
+        Parameters
+        ----------
+        errors: ErrorText
+            Mapping of device name to Exception or another NotConnected.
+            Alternatively a string with the signal error text.
+        """
+
+        self._errors = errors
+
+    def _format_sub_errors(self, name: str, error: Exception, indent="") -> str:
+        if isinstance(error, NotConnected):
+            error_txt = ":" + error.format_error_string(indent + self._indent_width)
+        elif isinstance(error, Exception):
+            error_txt = ": " + err_str + "\n" if (err_str := str(error)) else "\n"
+        else:
+            raise RuntimeError(
+                f"Unexpected type `{type(error)}`, expected an Exception"
+            )
+
+        string = f"{indent}{name}: {type(error).__name__}" + error_txt
+        return string
+
+    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`"
+            )
+
+        if isinstance(self._errors, str):
+            return " " + self._errors + "\n"
+
+        string = "\n"
+        for name, error in self._errors.items():
+            string += self._format_sub_errors(name, error, indent=indent)
+        return string
 
     def __str__(self) -> str:
-        return "\n".join(self.lines)
+        return self.format_error_string(indent="")
 
 
 async def wait_for_connection(**coros: Awaitable[None]):
-    """Call many underlying signals, accumulating `NotConnected` exceptions
+    """Call many underlying signals, accumulating exceptions and returning them
 
-    Raises
-    ------
-    `NotConnected` if cancelled
+    Expected kwargs should be a mapping of names to coroutine tasks to execute.
     """
-    ts = {k: asyncio.create_task(c) for (k, c) in coros.items()}  # type: ignore
-    try:
-        done, pending = await asyncio.wait(ts.values())
-    except asyncio.CancelledError:
-        for t in ts.values():
-            t.cancel()
-        lines: List[str] = []
-        for k, t in ts.items():
-            try:
-                await t
-            except NotConnected as e:
-                if len(e.lines) == 1:
-                    lines.append(f"{k}: {e.lines[0]}")
-                else:
-                    lines.append(f"{k}:")
-                    lines += [f"  {line}" for line in e.lines]
-        raise NotConnected(*lines)
-    else:
-        # Wait for everything to foreground the exceptions
-        for f in list(done) + list(pending):
-            await f
+    results = await asyncio.gather(*coros.values(), return_exceptions=True)
+    exceptions = {}
+
+    for name, result in zip(coros, results):
+        if isinstance(result, Exception):
+            exceptions[name] = result
+            if not isinstance(result, NotConnected):
+                logging.exception(
+                    f"device `{name}` raised unexpected exception "
+                    f"{type(result).__name__}",
+                    exc_info=result,
+                )
+
+    if exceptions:
+        raise NotConnected(exceptions)
 
 
 def get_dtype(typ: Type) -> Optional[np.dtype]:
@@ -98,3 +144,7 @@ async def merge_gathered_dicts(
     for result in await asyncio.gather(*coros):
         ret.update(result)
     return ret
+
+
+async def gather_list(coros: Iterable[Awaitable[T]]) -> List[T]:
+    return await asyncio.gather(*coros)

ophyd_async/epics/_backend/_aioca.py

@@ -1,5 +1,5 @@
+import logging
 import sys
-from asyncio import CancelledError
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, Optional, Sequence, Type, Union
@@ -8,6 +8,7 @@ from aioca import (
     FORMAT_CTRL,
     FORMAT_RAW,
     FORMAT_TIME,
+    CANothing,
     Subscription,
     caget,
     camonitor,
@@ -18,7 +19,6 @@ from bluesky.protocols import Descriptor, Dtype, Reading
 from epicscorelibs.ca import dbr
 
 from ophyd_async.core import (
-    NotConnected,
     ReadingValueCallback,
     SignalBackend,
     T,
@@ -26,6 +26,9 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
+
+from .common import get_supported_enum_class
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
@@ -59,6 +62,16 @@ class CaConverter:
         return dict(source=source, dtype=dbr_to_dtype[value.datatype], shape=[])
 
 
+class CaLongStrConverter(CaConverter):
+    def __init__(self):
+        return super().__init__(dbr.DBR_CHAR_STR, dbr.DBR_CHAR_STR)
+
+    def write_value(self, value: str):
+        # Add a null in here as this is what the commandline caput does
+        # TODO: this should be in the server so check if it can be pushed to asyn
+        return value + "\0"
+
+
 class CaArrayConverter(CaConverter):
     def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
         return dict(source=source, dtype="array", shape=[len(value)])
@@ -79,9 +92,7 @@ class CaEnumConverter(CaConverter):
 
     def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
         choices = [e.value for e in self.enum_class]
-        return dict(
-            source=source, dtype="string", shape=[], choices=choices
-        )  # type: ignore
+        return dict(source=source, dtype="string", shape=[], choices=choices)
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -97,7 +108,7 @@ def make_converter(
     is_array = bool([v for v in values.values() if v.element_count > 1])
     if is_array and datatype is str and pv_dbr == dbr.DBR_CHAR:
         # Override waveform of chars to be treated as string
-        return CaConverter(dbr.DBR_CHAR_STR, dbr.DBR_CHAR_STR)
+        return CaLongStrConverter()
     elif is_array and pv_dbr == dbr.DBR_STRING:
         # Waveform of strings, check we wanted this
         if datatype and datatype != Sequence[str]:
@@ -127,17 +138,7 @@ def make_converter(
         pv_choices = get_unique(
             {k: tuple(v.enums) for k, v in values.items()}, "choices"
         )
-        if datatype:
-            if not issubclass(datatype, Enum):
-                raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
-            choices = tuple(v.value for v in datatype)
-            if set(choices) != set(pv_choices):
-                raise TypeError(f"{pv} has choices {pv_choices} not {choices}")
-            enum_class = datatype
-        else:
-            enum_class = Enum(  # type: ignore
-                "GeneratedChoices", {x: x for x in pv_choices}, type=str
-            )
+        enum_class = get_supported_enum_class(pv, datatype, pv_choices)
         return CaEnumConverter(dbr.DBR_STRING, None, enum_class)
     else:
         value = list(values.values())[0]
@@ -172,23 +173,26 @@ class CaSignalBackend(SignalBackend[T]):
         self.source = f"ca://{self.read_pv}"
         self.subscription: Optional[Subscription] = None
 
-    async def _store_initial_value(self, pv):
+    async def _store_initial_value(self, pv, timeout: float = DEFAULT_TIMEOUT):
         try:
-            self.initial_values[pv] = await caget(pv, format=FORMAT_CTRL, timeout=None)
-        except CancelledError:
-            raise NotConnected(self.source)
+            self.initial_values[pv] = await caget(
+                pv, format=FORMAT_CTRL, timeout=timeout
+            )
+        except CANothing as exc:
+            logging.debug(f"signal ca://{pv} timed out")
+            raise NotConnected(f"ca://{pv}") from exc
 
-    async def connect(self):
+    async def connect(self, timeout: float = DEFAULT_TIMEOUT):
         _use_pyepics_context_if_imported()
         if self.read_pv != self.write_pv:
             # Different, need to connect both
             await wait_for_connection(
-                read_pv=self._store_initial_value(self.read_pv),
-                write_pv=self._store_initial_value(self.write_pv),
+                read_pv=self._store_initial_value(self.read_pv, timeout=timeout),
+                write_pv=self._store_initial_value(self.write_pv, timeout=timeout),
             )
         else:
             # The same, so only need to connect one
-            await self._store_initial_value(self.read_pv)
+            await self._store_initial_value(self.read_pv, timeout=timeout)
         self.converter = make_converter(self.datatype, self.initial_values)
 
     async def put(self, value: Optional[T], wait=True, timeout=None):
@@ -224,6 +228,15 @@ class CaSignalBackend(SignalBackend[T]):
         value = await self._caget(FORMAT_RAW)
         return self.converter.value(value)
 
+    async def get_setpoint(self) -> T:
+        value = await caget(
+            self.write_pv,
+            datatype=self.converter.read_dbr,
+            format=FORMAT_RAW,
+            timeout=None,
+        )
+        return self.converter.value(value)
+
     def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
         if callback:
             assert (

ophyd_async/epics/_backend/_p4p.py

@@ -1,6 +1,7 @@
 import asyncio
 import atexit
-from asyncio import CancelledError
+import logging
+import time
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, List, Optional, Sequence, Type, Union
@@ -10,7 +11,6 @@ from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 
 from ophyd_async.core import (
-    NotConnected,
     ReadingValueCallback,
     SignalBackend,
     T,
@@ -18,6 +18,9 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
+
+from .common import get_supported_enum_class
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {
@@ -119,9 +122,7 @@ class PvaEnumConverter(PvaConverter):
 
     def descriptor(self, source: str, value) -> Descriptor:
         choices = [e.value for e in self.enum_class]
-        return dict(
-            source=source, dtype="string", shape=[], choices=choices
-        )  # type: ignore
+        return dict(source=source, dtype="string", shape=[], choices=choices)
 
 
 class PvaEnumBoolConverter(PvaConverter):
@@ -141,6 +142,32 @@ class PvaTableConverter(PvaConverter):
         return dict(source=source, dtype="object", shape=[])  # type: ignore
 
 
+class PvaDictConverter(PvaConverter):
+    def reading(self, value):
+        ts = time.time()
+        value = value.todict()
+        # Alarm severity is vacuously 0 for a table
+        return dict(value=value, timestamp=ts, alarm_severity=0)
+
+    def value(self, value: Value):
+        return value.todict()
+
+    def descriptor(self, source: str, value) -> Descriptor:
+        raise NotImplementedError("Describing Dict signals not currently supported")
+
+    def metadata_fields(self) -> List[str]:
+        """
+        Fields to request from PVA for metadata.
+        """
+        return []
+
+    def value_fields(self) -> List[str]:
+        """
+        Fields to request from PVA for the value.
+        """
+        return []
+
+
 class DisconnectedPvaConverter(PvaConverter):
     def __getattribute__(self, __name: str) -> Any:
         raise NotImplementedError("No PV has been set as connect() has not been called")
@@ -149,7 +176,9 @@ class DisconnectedPvaConverter(PvaConverter):
 def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConverter:
     pv = list(values)[0]
     typeid = get_unique({k: v.getID() for k, v in values.items()}, "typeids")
-    typ = get_unique({k: type(v["value"]) for k, v in values.items()}, "value types")
+    typ = get_unique(
+        {k: type(v.get("value")) for k, v in values.items()}, "value types"
+    )
     if "NTScalarArray" in typeid and typ == list:
         # Waveform of strings, check we wanted this
         if datatype and datatype != Sequence[str]:
@@ -185,24 +214,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"
         )
-        if datatype:
-            if not issubclass(datatype, Enum):
-                raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
-            choices = tuple(v.value for v in datatype)
-            if set(choices) != set(pv_choices):
-                raise TypeError(f"{pv} has choices {pv_choices} not {choices}")
-            enum_class = datatype
-        else:
-            enum_class = Enum(  # type: ignore
-                "GeneratedChoices", {x: x for x in pv_choices}, type=str
-            )
-        return PvaEnumConverter(enum_class)
+        return PvaEnumConverter(get_supported_enum_class(pv, datatype, pv_choices))
     elif "NTScalar" in typeid:
         if datatype and not issubclass(typ, datatype):
             raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
         return PvaConverter()
     elif "NTTable" in typeid:
         return PvaTableConverter()
+    elif "structure" in typeid:
+        return PvaDictConverter()
     else:
         raise TypeError(f"{pv}: Unsupported typeid {typeid}")
 
@@ -233,22 +253,25 @@ class PvaSignalBackend(SignalBackend[T]):
 
         return PvaSignalBackend._ctxt
 
-    async def _store_initial_value(self, pv):
+    async def _store_initial_value(self, pv, timeout: float = DEFAULT_TIMEOUT):
         try:
-            self.initial_values[pv] = await self.ctxt.get(pv)
-        except CancelledError:
-            raise NotConnected(self.source)
+            self.initial_values[pv] = await asyncio.wait_for(
+                self.ctxt.get(pv), timeout=timeout
+            )
+        except asyncio.TimeoutError as exc:
+            logging.debug(f"signal pva://{pv} timed out", exc_info=True)
+            raise NotConnected(f"pva://{pv}") from exc
 
-    async def connect(self):
+    async def connect(self, timeout: float = DEFAULT_TIMEOUT):
         if self.read_pv != self.write_pv:
             # Different, need to connect both
             await wait_for_connection(
-                read_pv=self._store_initial_value(self.read_pv),
-                write_pv=self._store_initial_value(self.write_pv),
+                read_pv=self._store_initial_value(self.read_pv, timeout=timeout),
+                write_pv=self._store_initial_value(self.write_pv, timeout=timeout),
             )
         else:
             # The same, so only need to connect one
-            await self._store_initial_value(self.read_pv)
+            await self._store_initial_value(self.read_pv, timeout=timeout)
         self.converter = make_converter(self.datatype, self.initial_values)
 
     async def put(self, value: Optional[T], wait=True, timeout=None):
@@ -257,7 +280,15 @@ class PvaSignalBackend(SignalBackend[T]):
         else:
             write_value = self.converter.write_value(value)
         coro = self.ctxt.put(self.write_pv, dict(value=write_value), wait=wait)
-        await asyncio.wait_for(coro, timeout)
+        try:
+            await asyncio.wait_for(coro, timeout)
+        except asyncio.TimeoutError as exc:
+            logging.debug(
+                f"signal pva://{self.write_pv} timed out \
+                          put value: {write_value}",
+                exc_info=True,
+            )
+            raise NotConnected(f"pva://{self.write_pv}") from exc
 
     async def get_descriptor(self) -> Descriptor:
         value = await self.ctxt.get(self.read_pv)
@@ -282,6 +313,10 @@ class PvaSignalBackend(SignalBackend[T]):
         value = await self.ctxt.get(self.read_pv, request=request)
         return self.converter.value(value)
 
+    async def get_setpoint(self) -> T:
+        value = await self.ctxt.get(self.write_pv, "field(value)")
+        return self.converter.value(value)
+
     def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
         if callback:
             assert (

ophyd_async/epics/_backend/common.py

@@ -0,0 +1,20 @@
+from enum import Enum
+from typing import Any, Optional, Tuple, Type
+
+
+def get_supported_enum_class(
+    pv: str,
+    datatype: Optional[Type[Enum]],
+    pv_choices: Tuple[Any, ...],
+) -> Type[Enum]:
+    if datatype:
+        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).difference(pv_choices):
+            raise TypeError(f"{pv} has choices {pv_choices}: not all in {choices}")
+    return Enum(
+        "GeneratedChoices", {x or "_": x for x in pv_choices}, type=str
+    )  # type: ignore

ophyd_async/epics/areadetector/__init__.py

@@ -1,22 +1,19 @@
-from .ad_driver import ADDriver
-from .directory_provider import DirectoryProvider, TmpDirectoryProvider
-from .hdf_streamer_det import HDFStreamerDet
-from .nd_file_hdf import NDFileHDF
-from .nd_plugin import NDPlugin, NDPluginStats
 from .single_trigger_det import SingleTriggerDet
-from .utils import FileWriteMode, ImageMode, ad_r, ad_rw
+from .utils import (
+    FileWriteMode,
+    ImageMode,
+    NDAttributeDataType,
+    NDAttributesXML,
+    ad_r,
+    ad_rw,
+)
 
 __all__ = [
-    "ADDriver",
-    "DirectoryProvider",
-    "TmpDirectoryProvider",
-    "HDFStreamerDet",
-    "NDFileHDF",
-    "NDPlugin",
-    "NDPluginStats",
     "SingleTriggerDet",
     "FileWriteMode",
     "ImageMode",
     "ad_r",
     "ad_rw",
+    "NDAttributeDataType",
+    "NDAttributesXML",
 ]

ophyd_async/epics/areadetector/controllers/__init__.py

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

ophyd_async/epics/areadetector/controllers/ad_sim_controller.py

@@ -0,0 +1,52 @@
+import asyncio
+from typing import Optional, Set
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+)
+
+from ..drivers.ad_base import (
+    DEFAULT_GOOD_STATES,
+    ADBase,
+    DetectorState,
+    ImageMode,
+    start_acquiring_driver_and_ensure_status,
+)
+from ..utils import stop_busy_record
+
+
+class ADSimController(DetectorControl):
+    def __init__(
+        self, driver: ADBase, good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES)
+    ) -> None:
+        self.driver = driver
+        self.good_states = good_states
+
+    def get_deadtime(self, exposure: float) -> float:
+        return 0.002
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        assert (
+            trigger == DetectorTrigger.internal
+        ), "fly scanning (i.e. external triggering) is not supported for this device"
+        frame_timeout = DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        await asyncio.gather(
+            self.driver.num_images.set(num),
+            self.driver.image_mode.set(ImageMode.multiple),
+        )
+        return await start_acquiring_driver_and_ensure_status(
+            self.driver, good_states=self.good_states, timeout=frame_timeout
+        )
+
+    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)

ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -0,0 +1,49 @@
+import asyncio
+from typing import Optional, Set
+
+from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.epics.areadetector.drivers.ad_base import (
+    DEFAULT_GOOD_STATES,
+    DetectorState,
+    start_acquiring_driver_and_ensure_status,
+)
+
+from ..drivers.pilatus_driver import PilatusDriver, TriggerMode
+from ..utils import ImageMode, stop_busy_record
+
+TRIGGER_MODE = {
+    DetectorTrigger.internal: TriggerMode.internal,
+    DetectorTrigger.constant_gate: TriggerMode.ext_enable,
+    DetectorTrigger.variable_gate: TriggerMode.ext_enable,
+}
+
+
+class PilatusController(DetectorControl):
+    def __init__(
+        self,
+        driver: PilatusDriver,
+        good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES),
+    ) -> None:
+        self.driver = driver
+        self.good_states = good_states
+
+    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.driver.trigger_mode.set(TRIGGER_MODE[trigger]),
+            self.driver.num_images.set(999_999 if num == 0 else num),
+            self.driver.image_mode.set(ImageMode.multiple),
+        )
+        return await start_acquiring_driver_and_ensure_status(
+            self.driver, good_states=self.good_states
+        )
+
+    async def disarm(self):
+        await stop_busy_record(self.driver.acquire, False, timeout=1)

ophyd_async/epics/areadetector/drivers/__init__.py

@@ -0,0 +1,15 @@
+from .ad_base import (
+    ADBase,
+    ADBaseShapeProvider,
+    DetectorState,
+    start_acquiring_driver_and_ensure_status,
+)
+from .pilatus_driver import PilatusDriver
+
+__all__ = [
+    "ADBase",
+    "ADBaseShapeProvider",
+    "PilatusDriver",
+    "start_acquiring_driver_and_ensure_status",
+    "DetectorState",
+]