ophyd-async 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

ophyd_async/epics/core/_util.py

@@ -0,0 +1,61 @@
+from collections.abc import Sequence
+from typing import Any, get_args, get_origin
+
+import numpy as np
+
+from ophyd_async.core import (
+    SignalBackend,
+    SignalDatatypeT,
+    SubsetEnum,
+    get_dtype,
+    get_enum_cls,
+)
+
+
+def get_supported_values(
+    pv: str,
+    datatype: type,
+    pv_choices: Sequence[str],
+) -> dict[str, str]:
+    enum_cls = get_enum_cls(datatype)
+    if not enum_cls:
+        raise TypeError(f"{datatype} is not an Enum")
+    choices = [v.value for v in enum_cls]
+    error_msg = f"{pv} has choices {pv_choices}, but {datatype} requested {choices} "
+    if issubclass(enum_cls, SubsetEnum):
+        if not set(choices).issubset(pv_choices):
+            raise TypeError(error_msg + "to be a subset of them.")
+    else:
+        if set(choices) != set(pv_choices):
+            raise TypeError(error_msg + "to be strictly equal to them.")
+
+    # Take order from the pv choices
+    supported_values = {x: x for x in pv_choices}
+    # But override those that we specify via the datatype
+    for v in enum_cls:
+        supported_values[v.value] = v
+    return supported_values
+
+
+def format_datatype(datatype: Any) -> str:
+    if get_origin(datatype) is np.ndarray and get_args(datatype)[0] == tuple[int]:
+        dtype = get_dtype(datatype)
+        return f"Array1D[np.{dtype.name}]"
+    elif get_origin(datatype) is Sequence:
+        return f"Sequence[{get_args(datatype)[0].__name__}]"
+    elif isinstance(datatype, type):
+        return datatype.__name__
+    else:
+        return str(datatype)
+
+
+class EpicsSignalBackend(SignalBackend[SignalDatatypeT]):
+    def __init__(
+        self,
+        datatype: type[SignalDatatypeT] | None,
+        read_pv: str = "",
+        write_pv: str = "",
+    ):
+        self.read_pv = read_pv
+        self.write_pv = write_pv
+        super().__init__(datatype)

ophyd_async/epics/demo/_mover.py

@@ -8,15 +8,14 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    ConfigSignal,
     Device,
-    HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 
 class Mover(StandardReadable, Movable, Stoppable):
@@ -24,9 +23,9 @@ class Mover(StandardReadable, Movable, Stoppable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.readback = epics_signal_r(float, prefix + "Readback")
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.velocity = epics_signal_rw(float, prefix + "Velocity")
             self.units = epics_signal_r(str, prefix + "Readback.EGU")
         self.setpoint = epics_signal_rw(float, prefix + "Setpoint")

ophyd_async/epics/demo/_sensor.py

@@ -1,10 +1,17 @@
-from enum import Enum
+from typing import Annotated as A
 
-from ophyd_async.core import ConfigSignal, DeviceVector, HintedSignal, StandardReadable
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.core import (
+    DeviceVector,
+    SignalR,
+    SignalRW,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 
-class EnergyMode(str, Enum):
+class EnergyMode(StrictEnum):
     """Energy mode for `Sensor`"""
 
     #: Low energy mode
@@ -13,17 +20,11 @@ class EnergyMode(str, Enum):
     high = "High Energy"
 
 
-class Sensor(StandardReadable):
+class Sensor(StandardReadable, EpicsDevice):
     """A demo sensor that produces a scalar value based on X and Y Movers"""
 
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        with self.add_children_as_readables(HintedSignal):
-            self.value = epics_signal_r(float, prefix + "Value")
-        with self.add_children_as_readables(ConfigSignal):
-            self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
-
-        super().__init__(name=name)
+    value: A[SignalR[float], PvSuffix("Value"), Format.HINTED_SIGNAL]
+    mode: A[SignalRW[EnergyMode], PvSuffix("Mode"), Format.CONFIG_SIGNAL]
 
 
 class SensorGroup(StandardReadable):

ophyd_async/epics/eiger/_eiger.py

@@ -1,7 +1,6 @@
 from pydantic import Field
 
-from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector
-from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector, TriggerInfo
 
 from ._eiger_controller import EigerController
 from ._eiger_io import EigerDriverIO

ophyd_async/epics/eiger/_eiger_controller.py

@@ -4,9 +4,9 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     DetectorController,
     DetectorTrigger,
+    TriggerInfo,
     set_and_wait_for_other_value,
 )
-from ophyd_async.core._detector import TriggerInfo
 
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
 
@@ -55,7 +55,12 @@ class EigerController(DetectorController):
     async def arm(self):
         # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
         self._arm_status = set_and_wait_for_other_value(
-            self._drv.arm, 1, self._drv.state, "ready", timeout=DEFAULT_TIMEOUT
+            self._drv.arm,
+            1,
+            self._drv.state,
+            "ready",
+            timeout=DEFAULT_TIMEOUT,
+            wait_for_set_completion=False,
         )
 
     async def wait_for_idle(self):

ophyd_async/epics/eiger/_eiger_io.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import Device, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
 
-from ophyd_async.core import Device
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
 
-
-class EigerTriggerMode(str, Enum):
+class EigerTriggerMode(StrictEnum):
     internal = "ints"
     edge = "exts"
     gate = "exte"

ophyd_async/epics/eiger/_odin_io.py

@@ -1,6 +1,5 @@
 import asyncio
 from collections.abc import AsyncGenerator, AsyncIterator
-from enum import Enum
 
 from bluesky.protocols import StreamAsset
 from event_model import DataKey
@@ -12,17 +11,18 @@ from ophyd_async.core import (
     DeviceVector,
     NameProvider,
     PathProvider,
+    StrictEnum,
     observe_value,
     set_and_wait_for_value,
 )
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
 )
 
 
-class Writing(str, Enum):
+class Writing(StrictEnum):
     ON = "ON"
     OFF = "OFF"
 
@@ -101,10 +101,10 @@ class OdinWriter(DetectorWriter):
         return {
             "data": DataKey(
                 source=self._drv.file_name.source,
-                shape=data_shape,
+                shape=list(data_shape),
                 dtype="array",
                 # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
-                dtype_numpy="<u2",  # type: ignore
+                dtype_numpy="<u2",
                 external="STREAM:",
             )
         }

ophyd_async/epics/motor.py

@@ -14,14 +14,13 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    ConfigSignal,
-    HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 
 class MotorLimitsException(Exception):
@@ -61,11 +60,11 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.motor_egu = epics_signal_r(str, prefix + ".EGU")
             self.velocity = epics_signal_rw(float, prefix + ".VELO")
 
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.user_readback = epics_signal_r(float, prefix + ".RBV")
 
         self.user_setpoint = epics_signal_rw(float, prefix + ".VAL")

ophyd_async/epics/signal.py

@@ -0,0 +1,11 @@
+# back compat
+import warnings
+
+from .core import *  # noqa: F403
+
+warnings.warn(
+    DeprecationWarning(
+        "Use `ophyd_async.epics.core` instead of `ophyd_async.epics.signal` and `pvi`"
+    ),
+    stacklevel=2,
+)

ophyd_async/epics/testing/__init__.py

@@ -0,0 +1,24 @@
+from ._example_ioc import (
+    CA_PVA_RECORDS,
+    PVA_RECORDS,
+    ExampleCaDevice,
+    ExampleEnum,
+    ExamplePvaDevice,
+    ExampleTable,
+    connect_example_device,
+    get_example_ioc,
+)
+from ._utils import TestingIOC, generate_random_PV_prefix
+
+__all__ = [
+    "CA_PVA_RECORDS",
+    "PVA_RECORDS",
+    "ExampleCaDevice",
+    "ExampleEnum",
+    "ExamplePvaDevice",
+    "ExampleTable",
+    "connect_example_device",
+    "get_example_ioc",
+    "TestingIOC",
+    "generate_random_PV_prefix",
+]

ophyd_async/epics/testing/_example_ioc.py

@@ -0,0 +1,105 @@
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Annotated as A
+from typing import Literal
+
+import numpy as np
+
+from ophyd_async.core import (
+    Array1D,
+    SignalRW,
+    StrictEnum,
+    Table,
+)
+from ophyd_async.epics.core import (
+    EpicsDevice,
+    PvSuffix,
+)
+
+from ._utils import TestingIOC
+
+CA_PVA_RECORDS = str(Path(__file__).parent / "test_records.db")
+PVA_RECORDS = str(Path(__file__).parent / "test_records_pva.db")
+
+
+class ExampleEnum(StrictEnum):
+    a = "Aaa"
+    b = "Bbb"
+    c = "Ccc"
+
+
+class ExampleTable(Table):
+    bool: Array1D[np.bool_]
+    int: Array1D[np.int32]
+    float: Array1D[np.float64]
+    str: Sequence[str]
+    enum: Sequence[ExampleEnum]
+
+
+class ExampleCaDevice(EpicsDevice):
+    my_int: A[SignalRW[int], PvSuffix("int")]
+    my_float: A[SignalRW[float], PvSuffix("float")]
+    my_str: A[SignalRW[str], PvSuffix("str")]
+    my_bool: A[SignalRW[bool], PvSuffix("bool")]
+    enum: A[SignalRW[ExampleEnum], PvSuffix("enum")]
+    enum2: A[SignalRW[ExampleEnum], PvSuffix("enum2")]
+    bool_unnamed: A[SignalRW[bool], PvSuffix("bool_unnamed")]
+    partialint: A[SignalRW[int], PvSuffix("partialint")]
+    lessint: A[SignalRW[int], PvSuffix("lessint")]
+    uint8a: A[SignalRW[Array1D[np.uint8]], PvSuffix("uint8a")]
+    int16a: A[SignalRW[Array1D[np.int16]], PvSuffix("int16a")]
+    int32a: A[SignalRW[Array1D[np.int32]], PvSuffix("int32a")]
+    float32a: A[SignalRW[Array1D[np.float32]], PvSuffix("float32a")]
+    float64a: A[SignalRW[Array1D[np.float64]], PvSuffix("float64a")]
+    stra: A[SignalRW[Sequence[str]], PvSuffix("stra")]
+
+
+class ExamplePvaDevice(ExampleCaDevice):  # pva can support all signal types that ca can
+    int8a: A[SignalRW[Array1D[np.int8]], PvSuffix("int8a")]
+    uint16a: A[SignalRW[Array1D[np.uint16]], PvSuffix("uint16a")]
+    uint32a: A[SignalRW[Array1D[np.uint32]], PvSuffix("uint32a")]
+    int64a: A[SignalRW[Array1D[np.int64]], PvSuffix("int64a")]
+    uint64a: A[SignalRW[Array1D[np.uint64]], PvSuffix("uint64a")]
+    table: A[SignalRW[ExampleTable], PvSuffix("table")]
+    ntndarray_data: A[SignalRW[Array1D[np.int64]], PvSuffix("ntndarray:data")]
+
+
+async def connect_example_device(
+    ioc: TestingIOC, protocol: Literal["ca", "pva"]
+) -> ExamplePvaDevice | ExampleCaDevice:
+    """Helper function to return a connected example device.
+
+    Parameters
+    ----------
+
+    ioc: TestingIOC
+        TestingIOC configured to provide the records needed for the device
+
+    protocol: Literal["ca", "pva"]
+        The transport protocol of the device
+
+    Returns
+    -------
+    ExamplePvaDevice | ExampleCaDevice
+        a connected EpicsDevice with signals of many EPICS record types
+    """
+    device_cls = ExamplePvaDevice if protocol == "pva" else ExampleCaDevice
+    device = device_cls(f"{protocol}://{ioc.prefix_for(device_cls)}")
+    await device.connect()
+    return device
+
+
+def get_example_ioc() -> TestingIOC:
+    """Get TestingIOC instance with the example databases loaded.
+
+    Returns
+    -------
+    TestingIOC
+        instance with test_records.db loaded for ExampleCaDevice and
+        test_records.db and test_records_pva.db loaded for ExamplePvaDevice.
+    """
+    ioc = TestingIOC()
+    ioc.database_for(PVA_RECORDS, ExamplePvaDevice)
+    ioc.database_for(CA_PVA_RECORDS, ExamplePvaDevice)
+    ioc.database_for(CA_PVA_RECORDS, ExampleCaDevice)
+    return ioc

ophyd_async/epics/testing/_utils.py

@@ -0,0 +1,78 @@
+import random
+import string
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from aioca import purge_channel_caches
+
+from ophyd_async.core import Device
+
+
+def generate_random_PV_prefix() -> str:
+    return "".join(random.choice(string.ascii_lowercase) for _ in range(12)) + ":"
+
+
+class TestingIOC:
+    _dbs: dict[type[Device], list[Path]] = {}
+    _prefixes: dict[type[Device], str] = {}
+
+    @classmethod
+    def with_database(cls, db: Path | str):  # use as a decorator
+        def inner(device_cls: type[Device]):
+            cls.database_for(db, device_cls)
+            return device_cls
+
+        return inner
+
+    @classmethod
+    def database_for(cls, db, device_cls):
+        path = Path(db)
+        if not path.is_file():
+            raise OSError(f"{path} is not a file.")
+        if device_cls not in cls._dbs:
+            cls._dbs[device_cls] = []
+        cls._dbs[device_cls].append(path)
+
+    def prefix_for(self, device_cls):
+        # generate random prefix, return existing if already generated
+        return self._prefixes.setdefault(device_cls, generate_random_PV_prefix())
+
+    def start_ioc(self):
+        ioc_args = [
+            sys.executable,
+            "-m",
+            "epicscorelibs.ioc",
+        ]
+        for device_cls, dbs in self._dbs.items():
+            prefix = self.prefix_for(device_cls)
+            for db in dbs:
+                ioc_args += ["-m", f"device={prefix}", "-d", str(db)]
+        self._process = subprocess.Popen(
+            ioc_args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+        )
+        start_time = time.monotonic()
+        while "iocRun: All initialization complete" not in (
+            self._process.stdout.readline().strip()  # type: ignore
+        ):
+            if time.monotonic() - start_time > 10:
+                try:
+                    print(self._process.communicate("exit()")[0])
+                except ValueError:
+                    # Someone else already called communicate
+                    pass
+                raise TimeoutError("IOC did not start in time")
+
+    def stop_ioc(self):
+        # close backend caches before the event loop
+        purge_channel_caches()
+        try:
+            print(self._process.communicate("exit()")[0])
+        except ValueError:
+            # Someone else already called communicate
+            pass

ophyd_async/epics/testing/test_records.db

@@ -0,0 +1,152 @@
+record(bo, "$(device)bool") {
+  field(ZNAM, "No")
+  field(ONAM, "Yes")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(bo, "$(device)bool_unnamed") {
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(longout, "$(device)int") {
+  field(LLSV, "MAJOR") # LOLO is alarm
+  field(LSV, "MINOR") # LOW is warning
+  field(HSV, "MINOR") # HIGH is warning
+  field(HHSV, "MAJOR") # HIHI is alarm
+  field(HOPR, "100")
+  field(HIHI, "98")
+  field(HIGH, "96")
+  field(DRVH, "90")
+  field(DRVL, "10")
+  field(LOW, "5")
+  field(LOLO, "2")
+  field(LOPR, "0")
+  field(VAL, "42")
+  field(PINI, "YES")
+}
+
+record(longout, "$(device)partialint") {
+  field(LLSV, "MAJOR") # LOLO is alarm
+  field(HHSV, "MAJOR") # HIHI is alarm
+  field(HOPR, "100")
+  field(HIHI, "98")
+  field(DRVH, "90")
+  field(DRVL, "10")
+  field(LOLO, "2")
+  field(LOPR, "0")
+  field(VAL, "42")
+  field(PINI, "YES")
+}
+
+record(longout, "$(device)lessint") {
+  field(HSV, "MINOR") # LOW is warning
+  field(LSV, "MINOR") # HIGH is warning
+  field(HOPR, "100")
+  field(HIGH, "98")
+  field(LOW, "2")
+  field(LOPR, "0")
+  field(VAL, "42")
+  field(PINI, "YES")
+}
+
+record(ao, "$(device)float") {
+  field(PREC, "1")
+  field(EGU, "mm")
+  field(VAL, "3.141")
+  field(PINI, "YES")
+}
+
+record(ao, "$(device)float_prec_0") {
+  field(PREC, "0")
+  field(EGU, "mm")
+  field(VAL, "3")
+  field(PINI, "YES")
+}
+
+record(ao, "$(device)float_prec_1") {
+  field(PREC, "1")
+  field(EGU, "mm")
+  field(VAL, "3")
+  field(PINI, "YES")
+}
+
+record(stringout, "$(device)str") {
+  field(VAL, "hello")
+  field(PINI, "YES")
+}
+
+record(mbbo, "$(device)enum") {
+  field(ZRST, "Aaa")
+  field(ZRVL, "5")
+  field(ONST, "Bbb")
+  field(ONVL, "6")
+  field(TWST, "Ccc")
+  field(TWVL, "7")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(mbbo, "$(device)enum2") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)uint8a") {
+  field(NELM, "3")
+  field(FTVL, "UCHAR")
+  field(INP, {const:[0, 255]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)int16a") {
+  field(NELM, "3")
+  field(FTVL, "SHORT")
+  field(INP, {const:[-32768, 32767]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)int32a") {
+  field(NELM, "3")
+  field(FTVL, "LONG")
+  field(INP, {const:[-2147483648, 2147483647]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)float32a") {
+  field(NELM, "3")
+  field(FTVL, "FLOAT")
+  field(INP, {const:[0.000002, -123.123]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)float64a") {
+  field(NELM, "3")
+  field(FTVL, "DOUBLE")
+  field(INP, {const:[0.1, -12345678.123]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)stra") {
+  field(NELM, "3")
+  field(FTVL, "STRING")
+  field(INP, {const:["five", "six", "seven"]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)longstr") {
+  field(NELM, "80")
+  field(FTVL, "CHAR")
+  field(INP, {const:"a string that is just longer than forty characters"})
+  field(PINI, "YES")
+}
+
+record(lsi, "$(device)longstr2") {
+  field(SIZV, "80")
+  field(INP, {const:"a string that is just longer than forty characters"})
+  field(PINI, "YES")
+}