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

ophyd_async/epics/core/_p4p.py

@@ -31,6 +31,8 @@ from ophyd_async.core import (
 
 from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
+logger = logging.getLogger("ophyd_async")
+
 
 def _limits_from_value(value: Any) -> Limits:
     def get_limits(
@@ -39,7 +41,7 @@ def _limits_from_value(value: Any) -> Limits:
         substructure = getattr(value, substucture_name, None)
         low = getattr(substructure, low_name, nan)
         high = getattr(substructure, high_name, nan)
-        if not (isnan(low) and isnan(high)):
+        if not (isnan(low) and isnan(high)) and not low == high == 0:
             return LimitsRange(
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
@@ -60,12 +62,22 @@ def _limits_from_value(value: Any) -> Limits:
 def _metadata_from_value(datatype: type[SignalDatatype], value: Any) -> SignalMetadata:
     metadata = SignalMetadata()
     value_data: Any = getattr(value, "value", None)
+    specifier = _get_specifier(value)
     display_data: Any = getattr(value, "display", None)
-    if hasattr(display_data, "units"):
+    if (
+        hasattr(display_data, "units")
+        and specifier[-1] in _number_specifiers
+        and datatype is not str
+    ):
         metadata["units"] = display_data.units
-    if hasattr(display_data, "precision") and not isnan(display_data.precision):
+    if (
+        hasattr(display_data, "precision")
+        and not isnan(display_data.precision)
+        and specifier[-1] in _float_specifiers
+        and datatype is not int
+    ):
         metadata["precision"] = display_data.precision
-    if limits := _limits_from_value(value):
+    if (limits := _limits_from_value(value)) and specifier[-1] in _number_specifiers:
         metadata["limits"] = limits
     # Get choices from display or value
     if datatype is str or issubclass(datatype, StrictEnum):
@@ -84,9 +96,7 @@ class PvaConverter(Generic[SignalDatatypeT]):
         self.datatype = datatype
 
     def value(self, value: Any) -> SignalDatatypeT:
-        # for channel access ca_xxx classes, this
-        # invokes __pos__ operator to return an instance of
-        # the builtin base class
+        # Normally the value will be of the correct python type
         return value["value"]
 
     def write_value(self, value: Any) -> Any:
@@ -94,6 +104,31 @@ class PvaConverter(Generic[SignalDatatypeT]):
         return value
 
 
+class PvaIntConverter(PvaConverter[int]):
+    def __init__(self):
+        super().__init__(int)
+
+    def value(self, value: Any) -> int:
+        # Convert to an int
+        return int(value["value"])
+
+
+class PvaLongStringConverter(PvaConverter[str]):
+    def __init__(self):
+        super().__init__(str)
+
+    def value(self, value: Any) -> Any:
+        # Value here is a null terminated array of ascii codes.
+        # We strip out the null terminator, and convert each code
+        # to the corresponding char, joining into a string
+        return value["value"].tobytes().rstrip(b"\0").decode()
+
+    def write_value(self, value: Any) -> Any:
+        # Inverse of reading - convert each character into it's ascii code,
+        # put into a list, and add null terminator.
+        return np.frombuffer(str(value).encode() + b"\0", dtype=np.int8)
+
+
 class DisconnectedPvaConverter(PvaConverter):
     def __getattribute__(self, __name: str) -> Any:
         raise NotImplementedError("No PV has been set as connect() has not been called")
@@ -158,6 +193,9 @@ class PvaTableConverter(PvaConverter[Table]):
 
 
 # https://mdavidsaver.github.io/p4p/values.html
+_float_specifiers = {"f", "d"}
+_int_specifiers = {"b", "B", "h", "H", "i", "I", "l", "L"}
+_number_specifiers = _float_specifiers.union(_int_specifiers)
 _datatype_converter_from_typeid: dict[
     tuple[str, str], tuple[type[SignalDatatype], type[PvaConverter]]
 ] = {
@@ -192,7 +230,7 @@ _datatype_converter_from_typeid: dict[
 }
 
 
-def _get_specifier(value: Value):
+def _get_specifier(value: Value) -> str:
     typ = value.type("value").aspy()
     if isinstance(typ, tuple):
         return typ[0]
@@ -242,7 +280,7 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
         == 0
     ):
         # Allow int signals to represent float records when prec is 0
-        return PvaConverter(int)
+        return PvaIntConverter()
     elif inferred_datatype is str and (enum_cls := get_enum_cls(datatype)):
         # Allow strings to be used as enums until QSRV supports this
         return PvaConverter(str)
@@ -252,6 +290,9 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
     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)
+    # Allow waveforms with FTVL=CHAR to be treated as str when requested
+    elif datatype is str and inferred_datatype == Array1D[np.int8]:
+        return PvaLongStringConverter()
     raise TypeError(
         f"{pv} with inferred datatype {format_datatype(inferred_datatype)}"
         f" from {typeid=} {specifier=}"
@@ -282,7 +323,7 @@ async def pvget_with_timeout(pv: str, timeout: float) -> Any:
     try:
         return await asyncio.wait_for(context().get(pv), timeout=timeout)
     except asyncio.TimeoutError as exc:
-        logging.debug(f"signal pva://{pv} timed out", exc_info=True)
+        logger.debug(f"signal pva://{pv} timed out", exc_info=True)
         raise NotConnected(f"pva://{pv}") from exc
 
 
@@ -364,10 +405,15 @@ class PvaSignalBackend(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"
 
             async def async_callback(v):
                 callback(self._make_reading(v))
@@ -378,6 +424,3 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             self.subscription = context().monitor(
                 self.read_pv, async_callback, request=request
             )
-        elif self.subscription:
-            self.subscription.close()
-            self.subscription = None

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,
@@ -38,7 +47,7 @@ def get_supported_values(
 
 
 def format_datatype(datatype: Any) -> str:
-    if get_origin(datatype) is np.ndarray and get_args(datatype)[0] == tuple[int]:
+    if get_origin(datatype) is np.ndarray and get_args(datatype):
         dtype = get_dtype(datatype)
         return f"Array1D[np.{dtype.name}]"
     elif get_origin(datatype) is Sequence:

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):
@@ -63,6 +63,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         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")
+            self.offset = epics_signal_rw(float, prefix + ".OFF")
 
         with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.user_readback = epics_signal_r(float, prefix + ".RBV")
@@ -76,7 +77,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 +95,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)
 
@@ -122,9 +126,9 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
     @AsyncStatus.wrap
     async def kickoff(self):
         """Begin moving motor from prepared position to final position."""
-        assert (
-            self._fly_completed_position
-        ), "Motor must be prepared before attempting to kickoff"
+        if not self._fly_completed_position:
+            msg = "Motor must be prepared before attempting to kickoff"
+            raise RuntimeError(msg)
 
         self._fly_status = self.set(
             self._fly_completed_position, timeout=self._fly_timeout
@@ -132,7 +136,9 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
 
     def complete(self) -> WatchableAsyncStatus:
         """Mark as complete once motor reaches completed position."""
-        assert self._fly_status, "kickoff not called"
+        if not self._fly_status:
+            msg = "kickoff not called"
+            raise RuntimeError(msg)
         return self._fly_status
 
     @WatchableAsyncStatus.wrap
@@ -152,13 +158,18 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
             self.velocity.get_value(),
             self.acceleration_time.get_value(),
         )
+
         if timeout is CALCULATE_TIMEOUT:
-            assert velocity > 0, "Motor has zero velocity"
-            timeout = (
-                abs(new_position - old_position) / velocity
-                + 2 * acceleration_time
-                + DEFAULT_TIMEOUT
-            )
+            try:
+                timeout = (
+                    abs((new_position - old_position) / velocity)
+                    + 2 * acceleration_time
+                    + DEFAULT_TIMEOUT
+                )
+            except ZeroDivisionError as error:
+                msg = "Mover has zero velocity"
+                raise ValueError(msg) from error
+
         move_status = self.user_setpoint.set(new_position, wait=True, timeout=timeout)
         async for current_position in observe_value(
             self.user_readback, done_status=move_status
@@ -178,7 +189,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/sim/_ioc.py

@@ -0,0 +1,29 @@
+import atexit
+from pathlib import Path
+
+from ophyd_async.epics.testing import TestingIOC
+
+HERE = Path(__file__).absolute().parent
+
+
+def start_ioc_subprocess(prefix: str, num_counters: int):
+    """Start an IOC subprocess with EPICS database for sample stage and sensor
+    with the same pv prefix
+    """
+    ioc = TestingIOC()
+    # Create X and Y motors
+    for suffix in ["X", "Y"]:
+        ioc.add_database(HERE / "mover.db", P=f"{prefix}STAGE:{suffix}:")
+    # Create a multichannel counter with num_counters
+    ioc.add_database(HERE / "multichannelcounter.db", P=f"{prefix}MCC:")
+    for i in range(1, num_counters + 1):
+        ioc.add_database(
+            HERE / "counter.db",
+            P=f"{prefix}MCC:",
+            CHANNEL=str(i),
+            X=f"{prefix}STAGE:X:",
+            Y=f"{prefix}STAGE:Y:",
+        )
+    # Start IOC and register it to be stopped at exit
+    ioc.start()
+    atexit.register(ioc.stop)

ophyd_async/epics/{demo → sim}/_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)
 
@@ -52,13 +52,19 @@ class Mover(StandardReadable, Movable, Stoppable):
             self.precision.get_value(),
             self.velocity.get_value(),
         )
-        if timeout == CALCULATE_TIMEOUT:
-            assert velocity > 0, "Mover has zero velocity"
-            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
+        if timeout is CALCULATE_TIMEOUT:
+            try:
+                timeout = (
+                    abs((new_position - old_position) / velocity) + DEFAULT_TIMEOUT
+                )
+            except ZeroDivisionError as error:
+                msg = "Mover has zero velocity"
+                raise ValueError(msg) from error
+
         # Make an Event that will be set on completion, and a Status that will
         # error if not done in time
         done = asyncio.Event()
-        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))
+        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))  # type: ignore
         # Wait for the value to set, but don't wait for put completion callback
         await self.setpoint.set(new_position, wait=False)
         async for current_position in observe_value(

ophyd_async/epics/{demo → sim}/_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/testing/__init__.py

@@ -0,0 +1,24 @@
+from ._example_ioc import (
+    CA_PVA_RECORDS,
+    PVA_RECORDS,
+    EpicsTestCaDevice,
+    EpicsTestEnum,
+    EpicsTestIocAndDevices,
+    EpicsTestPvaDevice,
+    EpicsTestSubsetEnum,
+    EpicsTestTable,
+)
+from ._utils import TestingIOC, generate_random_pv_prefix
+
+__all__ = [
+    "CA_PVA_RECORDS",
+    "PVA_RECORDS",
+    "EpicsTestCaDevice",
+    "EpicsTestEnum",
+    "EpicsTestSubsetEnum",
+    "EpicsTestPvaDevice",
+    "EpicsTestTable",
+    "EpicsTestIocAndDevices",
+    "TestingIOC",
+    "generate_random_pv_prefix",
+]

ophyd_async/epics/testing/_example_ioc.py

@@ -0,0 +1,91 @@
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Annotated as A
+
+import numpy as np
+
+from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, Table
+from ophyd_async.core._utils import SubsetEnum
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
+
+from ._utils import TestingIOC, generate_random_pv_prefix
+
+CA_PVA_RECORDS = Path(__file__).parent / "test_records.db"
+PVA_RECORDS = Path(__file__).parent / "test_records_pva.db"
+
+
+class EpicsTestEnum(StrictEnum):
+    A = "Aaa"
+    B = "Bbb"
+    C = "Ccc"
+
+
+class EpicsTestSubsetEnum(SubsetEnum):
+    A = "Aaa"
+    B = "Bbb"
+
+
+class EpicsTestTable(Table):
+    bool: Array1D[np.bool_]
+    int: Array1D[np.int32]
+    float: Array1D[np.float64]
+    str: Sequence[str]
+    enum: Sequence[EpicsTestEnum]
+
+
+class EpicsTestCaDevice(EpicsDevice):
+    my_int: A[SignalRW[int], PvSuffix("int")]
+    my_float: A[SignalRW[float], PvSuffix("float")]
+    float_prec_0: A[SignalRW[int], PvSuffix("float_prec_0")]
+    my_str: A[SignalRW[str], PvSuffix("str")]
+    longstr: A[SignalRW[str], PvSuffix("longstr")]
+    longstr2: A[SignalRW[str], PvSuffix("longstr2.VAL$")]
+    my_bool: A[SignalRW[bool], PvSuffix("bool")]
+    enum: A[SignalRW[EpicsTestEnum], PvSuffix("enum")]
+    enum2: A[SignalRW[EpicsTestEnum], PvSuffix("enum2")]
+    subset_enum: A[SignalRW[EpicsTestSubsetEnum], PvSuffix("subset_enum")]
+    enum_str_fallback: A[SignalRW[str], PvSuffix("enum_str_fallback")]
+    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 EpicsTestPvaDevice(EpicsTestCaDevice):
+    # 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[EpicsTestTable], PvSuffix("table")]
+    ntndarray: A[SignalR[np.ndarray], PvSuffix("ntndarray")]
+
+
+class EpicsTestIocAndDevices:
+    def __init__(self):
+        self.prefix = generate_random_pv_prefix()
+        self.ioc = TestingIOC()
+        # Create supporting records and ExampleCaDevice
+        ca_prefix = f"{self.prefix}ca:"
+        self.ioc.add_database(CA_PVA_RECORDS, device=ca_prefix)
+        self.ca_device = EpicsTestCaDevice(f"ca://{ca_prefix}")
+        # Create supporting records and ExamplePvaDevice
+        pva_prefix = f"{self.prefix}pva:"
+        self.ioc.add_database(CA_PVA_RECORDS, device=pva_prefix)
+        self.ioc.add_database(PVA_RECORDS, device=pva_prefix)
+        self.pva_device = EpicsTestPvaDevice(f"pva://{pva_prefix}")
+
+    def get_device(self, protocol: str) -> EpicsTestCaDevice | EpicsTestPvaDevice:
+        return getattr(self, f"{protocol}_device")
+
+    def get_signal(self, protocol: str, name: str) -> SignalRW:
+        return getattr(self.get_device(protocol), name)
+
+    def get_pv(self, protocol: str, name: str) -> str:
+        return f"{protocol}://{self.prefix}{protocol}:{name}"

ophyd_async/epics/testing/_utils.py

@@ -0,0 +1,50 @@
+import random
+import string
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def generate_random_pv_prefix() -> str:
+    return "".join(random.choice(string.ascii_lowercase) for _ in range(12)) + ":"
+
+
+class TestingIOC:
+    def __init__(self):
+        self._db_macros: list[tuple[Path, dict[str, str]]] = []
+        self.output = ""
+
+    def add_database(self, db: Path | str, /, **macros: str):
+        self._db_macros.append((Path(db), macros))
+
+    def start(self):
+        ioc_args = [
+            sys.executable,
+            "-m",
+            "epicscorelibs.ioc",
+        ]
+        for db, macros in self._db_macros:
+            macro_str = ",".join(f"{k}={v}" for k, v in macros.items())
+            ioc_args += ["-m", macro_str, "-d", str(db)]
+        self._process = subprocess.Popen(
+            ioc_args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+        )
+        assert self._process.stdout  # noqa: S101 # this is to make Pylance happy
+        start_time = time.monotonic()
+        while "iocRun: All initialization complete" not in self.output:
+            if time.monotonic() - start_time > 10:
+                self.stop()
+                raise TimeoutError(f"IOC did not start in time:\n{self.output}")
+            self.output += self._process.stdout.readline()
+
+    def stop(self):
+        try:
+            self.output += self._process.communicate("exit()")[0]
+        except ValueError:
+            # Someone else already called communicate
+            pass