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

ophyd_async/epics/core/_pvi_connector.py

@@ -32,10 +32,11 @@ def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
 
 
 class PviDeviceConnector(DeviceConnector):
-    def __init__(self, prefix: str = "") -> None:
+    def __init__(self, prefix: str = "", error_hint: str = "") -> None:
         # TODO: what happens if we get a leading "pva://" here?
         self.prefix = prefix
         self.pvi_pv = prefix + "PVI"
+        self.error_hint = error_hint
 
     def create_children_from_annotations(self, device: Device):
         if not hasattr(self, "filler"):
@@ -85,7 +86,8 @@ class PviDeviceConnector(DeviceConnector):
                     if e:
                         self._fill_child(name, e, i)
         # Check that all the requested children have been filled
-        self.filler.check_filled(f"{self.pvi_pv}: {entries}")
+        suffix = f"\n{self.error_hint}" if self.error_hint else ""
+        self.filler.check_filled(f"{self.pvi_pv}: {entries}{suffix}")
         # Set the name of the device to name all children
         device.set_name(device.name)
         return await super().connect_real(device, timeout, force_reconnect)

ophyd_async/epics/core/_signal.py

@@ -14,7 +14,7 @@ from ophyd_async.core import (
     get_unique,
 )
 
-from ._util import EpicsSignalBackend
+from ._util import EpicsSignalBackend, get_pv_basename_and_field
 
 
 class EpicsProtocol(Enum):
@@ -124,7 +124,14 @@ def epics_signal_rw_rbv(
     read_suffix:
         Append this suffix to the write pv to create the readback pv
     """
-    return epics_signal_rw(datatype, f"{write_pv}{read_suffix}", write_pv, name)
+
+    base_pv, field = get_pv_basename_and_field(write_pv)
+    if field is not None:
+        read_pv = f"{base_pv}{read_suffix}.{field}"
+    else:
+        read_pv = f"{write_pv}{read_suffix}"
+
+    return epics_signal_rw(datatype, read_pv, write_pv, name)
 
 
 def epics_signal_r(

ophyd_async/epics/core/_util.py

@@ -12,6 +12,15 @@ from ophyd_async.core import (
 )
 
 
+def get_pv_basename_and_field(pv: str) -> tuple[str, str | None]:
+    """Simple utility function for extracting base pv name without field"""
+
+    if "." in pv:
+        return (pv.split(".", -1)[0], pv.split(".", -1)[1])
+    else:
+        return (pv, None)
+
+
 def get_supported_values(
     pv: str,
     datatype: type,

ophyd_async/epics/demo/_mover.py

@@ -37,8 +37,8 @@ class Mover(StandardReadable, Movable, Stoppable):
 
         super().__init__(name=name)
 
-    def set_name(self, name: str):
-        super().set_name(name)
+    def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
+        super().set_name(name, child_name_separator=child_name_separator)
         # Readback should be named the same as its parent in read()
         self.readback.set_name(name)
 

ophyd_async/epics/demo/_sensor.py

@@ -15,9 +15,9 @@ class EnergyMode(StrictEnum):
     """Energy mode for `Sensor`"""
 
     #: Low energy mode
-    low = "Low Energy"
+    LOW = "Low Energy"
     #: High energy mode
-    high = "High Energy"
+    HIGH = "High Energy"
 
 
 class Sensor(StandardReadable, EpicsDevice):

ophyd_async/epics/eiger/_eiger_controller.py

@@ -11,10 +11,10 @@ from ophyd_async.core import (
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
 
 EIGER_TRIGGER_MODE_MAP = {
-    DetectorTrigger.internal: EigerTriggerMode.internal,
-    DetectorTrigger.constant_gate: EigerTriggerMode.gate,
-    DetectorTrigger.variable_gate: EigerTriggerMode.gate,
-    DetectorTrigger.edge_trigger: EigerTriggerMode.edge,
+    DetectorTrigger.INTERNAL: EigerTriggerMode.INTERNAL,
+    DetectorTrigger.CONSTANT_GATE: EigerTriggerMode.GATE,
+    DetectorTrigger.VARIABLE_GATE: EigerTriggerMode.GATE,
+    DetectorTrigger.EDGE_TRIGGER: EigerTriggerMode.EDGE,
 }
 
 
@@ -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

@@ -3,9 +3,9 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_si
 
 
 class EigerTriggerMode(StrictEnum):
-    internal = "ints"
-    edge = "exts"
-    gate = "exte"
+    INTERNAL = "ints"
+    EDGE = "exts"
+    GATE = "exte"
 
 
 class EigerDriverIO(Device):

ophyd_async/epics/motor.py

@@ -20,7 +20,7 @@ from ophyd_async.core import (
     observe_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
 
 class MotorLimitsException(Exception):
@@ -76,7 +76,10 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
         self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
 
-        self.motor_stop = epics_signal_x(prefix + ".STOP")
+        # Note:cannot use epics_signal_x here, as the motor record specifies that
+        # we must write 1 to stop the motor. Simply processing the record is not
+        # sufficient.
+        self.motor_stop = epics_signal_w(int, prefix + ".STOP")
         # Whether set() should complete successfully or not
         self._set_success = True
 
@@ -91,8 +94,8 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
 
         super().__init__(name=name)
 
-    def set_name(self, name: str):
-        super().set_name(name)
+    def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
+        super().set_name(name, child_name_separator=child_name_separator)
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
@@ -178,7 +181,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         self._set_success = success
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
-        await self.motor_stop.trigger(wait=False)
+        await self.motor_stop.set(1, wait=False)
 
     async def _prepare_velocity(
         self, start_position: float, end_position: float, time_for_move: float

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,107 @@
+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")]
+    longstr: A[SignalRW[str], PvSuffix("longstr")]
+    longstr2: A[SignalRW[str], PvSuffix("longstr2")]
+    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,158 @@
+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")
+}
+
+record(calc, "$(device)ticking") {
+  field(INPA, "$(device)ticking")
+  field(CALC, "A+1")
+  field(SCAN, ".1 second")
+}