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

ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StrictEnum
 from ophyd_async.epics import adcore
-from ophyd_async.epics.signal import epics_signal_rw_rbv
+from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class KinetixTriggerMode(StrictEnum):

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StrictEnum
 from ophyd_async.epics import adcore
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv
 
 
 class PilatusTriggerMode(StrictEnum):

ophyd_async/epics/advimba/_vimba_io.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StrictEnum
 from ophyd_async.epics import adcore
-from ophyd_async.epics.signal import epics_signal_rw_rbv
+from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class VimbaPixelFormat(StrictEnum):

ophyd_async/epics/core/__init__.py

@@ -0,0 +1,26 @@
+from ._epics_connector import EpicsDeviceConnector, PvSuffix
+from ._epics_device import EpicsDevice
+from ._pvi_connector import PviDeviceConnector
+from ._signal import (
+    CaSignalBackend,
+    PvaSignalBackend,
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+    epics_signal_w,
+    epics_signal_x,
+)
+
+__all__ = [
+    "PviDeviceConnector",
+    "EpicsDeviceConnector",
+    "PvSuffix",
+    "EpicsDevice",
+    "CaSignalBackend",
+    "PvaSignalBackend",
+    "epics_signal_r",
+    "epics_signal_rw",
+    "epics_signal_rw_rbv",
+    "epics_signal_w",
+    "epics_signal_x",
+]

ophyd_async/epics/{signal → core}/_aioca.py

@@ -24,7 +24,6 @@ from ophyd_async.core import (
     Array1D,
     Callback,
     NotConnected,
-    SignalBackend,
     SignalDatatype,
     SignalDatatypeT,
     SignalMetadata,
@@ -34,7 +33,7 @@ from ophyd_async.core import (
     wait_for_connection,
 )
 
-from ._common import format_datatype, get_supported_values
+from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
 
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
@@ -227,19 +226,17 @@ def _use_pyepics_context_if_imported():
         _tried_pyepics = True
 
 
-class CaSignalBackend(SignalBackend[SignalDatatypeT]):
+class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
     def __init__(
         self,
         datatype: type[SignalDatatypeT] | None,
         read_pv: str = "",
         write_pv: str = "",
     ):
-        self.read_pv = read_pv
-        self.write_pv = write_pv
         self.converter: CaConverter = DisconnectedCaConverter(float, dbr.DBR_DOUBLE)
         self.initial_values: dict[str, AugmentedValue] = {}
         self.subscription: Subscription | None = None
-        super().__init__(datatype)
+        super().__init__(datatype, read_pv, write_pv)
 
     def source(self, name: str, read: bool):
         return f"ca://{self.read_pv if read else self.write_pv}"

ophyd_async/epics/core/_epics_connector.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ophyd_async.core import Device, DeviceConnector, DeviceFiller
+
+from ._signal import EpicsSignalBackend, get_signal_backend_type, split_protocol_from_pv
+
+
+@dataclass
+class PvSuffix:
+    read_suffix: str
+    write_suffix: str | None = None
+
+    @classmethod
+    def rbv(cls, write_suffix: str, rbv_suffix: str = "_RBV") -> PvSuffix:
+        return cls(write_suffix + rbv_suffix, write_suffix)
+
+
+def fill_backend_with_prefix(
+    prefix: str, backend: EpicsSignalBackend, annotations: list[Any]
+):
+    unhandled = []
+    while annotations:
+        annotation = annotations.pop(0)
+        if isinstance(annotation, PvSuffix):
+            backend.read_pv = prefix + annotation.read_suffix
+            backend.write_pv = prefix + (
+                annotation.write_suffix or annotation.read_suffix
+            )
+        else:
+            unhandled.append(annotation)
+    annotations.extend(unhandled)
+    # These leftover annotations will now be handled by the iterator
+
+
+class EpicsDeviceConnector(DeviceConnector):
+    def __init__(self, prefix: str) -> None:
+        self.prefix = prefix
+
+    def create_children_from_annotations(self, device: Device):
+        if not hasattr(self, "filler"):
+            protocol, prefix = split_protocol_from_pv(self.prefix)
+            self.filler = DeviceFiller(
+                device,
+                signal_backend_factory=get_signal_backend_type(protocol),
+                device_connector_factory=DeviceConnector,
+            )
+            for backend, annotations in self.filler.create_signals_from_annotations():
+                fill_backend_with_prefix(prefix, backend, annotations)
+
+            list(self.filler.create_devices_from_annotations())

ophyd_async/epics/core/_epics_device.py

@@ -0,0 +1,13 @@
+from ophyd_async.core import Device
+
+from ._epics_connector import EpicsDeviceConnector
+from ._pvi_connector import PviDeviceConnector
+
+
+class EpicsDevice(Device):
+    def __init__(self, prefix: str, with_pvi: bool = False, name: str = ""):
+        if with_pvi:
+            connector = PviDeviceConnector(prefix)
+        else:
+            connector = EpicsDeviceConnector(prefix)
+        super().__init__(name=name, connector=connector)

ophyd_async/epics/{signal → core}/_p4p.py

@@ -18,7 +18,6 @@ from ophyd_async.core import (
     Array1D,
     Callback,
     NotConnected,
-    SignalBackend,
     SignalDatatype,
     SignalDatatypeT,
     SignalMetadata,
@@ -30,7 +29,7 @@ from ophyd_async.core import (
     wait_for_connection,
 )
 
-from ._common import format_datatype, get_supported_values
+from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
 
 def _limits_from_value(value: Any) -> Limits:
@@ -293,19 +292,17 @@ def _pva_request_string(fields: Sequence[str]) -> str:
     return f"field({','.join(fields)})"
 
 
-class PvaSignalBackend(SignalBackend[SignalDatatypeT]):
+class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
     def __init__(
         self,
         datatype: type[SignalDatatypeT] | None,
         read_pv: str = "",
         write_pv: str = "",
     ):
-        self.read_pv = read_pv
-        self.write_pv = write_pv
         self.converter: PvaConverter = DisconnectedPvaConverter(float)
         self.initial_values: dict[str, Any] = {}
         self.subscription: Subscription | None = None
-        super().__init__(datatype)
+        super().__init__(datatype, read_pv, write_pv)
 
     def source(self, name: str, read: bool):
         return f"pva://{self.read_pv if read else self.write_pv}"

ophyd_async/epics/core/_pvi_connector.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from ophyd_async.core import (
+    Device,
+    DeviceConnector,
+    DeviceFiller,
+    Signal,
+    SignalR,
+    SignalRW,
+    SignalX,
+)
+from ophyd_async.core._utils import LazyMock
+
+from ._epics_connector import fill_backend_with_prefix
+from ._signal import PvaSignalBackend, pvget_with_timeout
+
+Entry = dict[str, str]
+
+
+def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
+    match entry:
+        case {"r": read_pv}:
+            return SignalR, read_pv, read_pv
+        case {"r": read_pv, "w": write_pv}:
+            return SignalRW, read_pv, write_pv
+        case {"rw": read_write_pv}:
+            return SignalRW, read_write_pv, read_write_pv
+        case {"x": execute_pv}:
+            return SignalX, execute_pv, execute_pv
+        case _:
+            raise TypeError(f"Can't process entry {entry}")
+
+
+class PviDeviceConnector(DeviceConnector):
+    def __init__(self, prefix: str = "") -> None:
+        # TODO: what happens if we get a leading "pva://" here?
+        self.prefix = prefix
+        self.pvi_pv = prefix + "PVI"
+
+    def create_children_from_annotations(self, device: Device):
+        if not hasattr(self, "filler"):
+            self.filler = DeviceFiller(
+                device=device,
+                signal_backend_factory=PvaSignalBackend,
+                device_connector_factory=PviDeviceConnector,
+            )
+            # Devices will be created with unfilled PviDeviceConnectors
+            list(self.filler.create_devices_from_annotations(filled=False))
+            # Signals can be filled in with EpicsSignalSuffix and checked at runtime
+            for backend, annotations in self.filler.create_signals_from_annotations(
+                filled=False
+            ):
+                fill_backend_with_prefix(self.prefix, backend, annotations)
+            self.filler.check_created()
+
+    def _fill_child(self, name: str, entry: Entry, vector_index: int | None = None):
+        if set(entry) == {"d"}:
+            connector = self.filler.fill_child_device(name, vector_index=vector_index)
+            connector.pvi_pv = entry["d"]
+        else:
+            signal_type, read_pv, write_pv = _get_signal_details(entry)
+            backend = self.filler.fill_child_signal(name, signal_type, vector_index)
+            backend.read_pv = read_pv
+            backend.write_pv = write_pv
+
+    async def connect_mock(self, device: Device, mock: LazyMock):
+        self.filler.create_device_vector_entries_to_mock(2)
+        # Set the name of the device to name all children
+        device.set_name(device.name)
+        return await super().connect_mock(device, mock)
+
+    async def connect_real(
+        self, device: Device, timeout: float, force_reconnect: bool
+    ) -> None:
+        pvi_structure = await pvget_with_timeout(self.pvi_pv, timeout)
+        entries: dict[str, Entry | list[Entry | None]] = pvi_structure["value"].todict()
+        # Fill based on what PVI gives us
+        for name, entry in entries.items():
+            if isinstance(entry, dict):
+                # This is a child
+                self._fill_child(name, entry)
+            else:
+                # This is a DeviceVector of children
+                for i, e in enumerate(entry):
+                    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}")
+        # 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/{signal → core}/_signal.py

@@ -14,13 +14,7 @@ from ophyd_async.core import (
     get_unique,
 )
 
-
-def _make_unavailable_class(error: Exception) -> type:
-    class TransportNotAvailable:
-        def __init__(*args, **kwargs):
-            raise NotImplementedError("Transport not available") from error
-
-    return TransportNotAvailable
+from ._util import EpicsSignalBackend
 
 
 class EpicsProtocol(Enum):
@@ -30,10 +24,26 @@ class EpicsProtocol(Enum):
 
 _default_epics_protocol = EpicsProtocol.CA
 
+
+def _make_unavailable_function(error: Exception):
+    def transport_not_available(*args, **kwargs):
+        raise NotImplementedError("Transport not available") from error
+
+    return transport_not_available
+
+
+def _make_unavailable_class(error: Exception) -> type[EpicsSignalBackend]:
+    class TransportNotAvailable(EpicsSignalBackend):
+        __init__ = _make_unavailable_function(error)
+
+    return TransportNotAvailable
+
+
 try:
-    from ._p4p import PvaSignalBackend
+    from ._p4p import PvaSignalBackend, pvget_with_timeout
 except ImportError as pva_error:
     PvaSignalBackend = _make_unavailable_class(pva_error)
+    pvget_with_timeout = _make_unavailable_function(pva_error)
 else:
     _default_epics_protocol = EpicsProtocol.PVA
 
@@ -45,7 +55,7 @@ else:
     _default_epics_protocol = EpicsProtocol.CA
 
 
-def _protocol_pv(pv: str) -> tuple[EpicsProtocol, str]:
+def split_protocol_from_pv(pv: str) -> tuple[EpicsProtocol, str]:
     split = pv.split("://", 1)
     if len(split) > 1:
         # We got something like pva://mydevice, so use specified comms mode
@@ -57,18 +67,23 @@ def _protocol_pv(pv: str) -> tuple[EpicsProtocol, str]:
     return protocol, pv
 
 
+def get_signal_backend_type(protocol: EpicsProtocol) -> type[EpicsSignalBackend]:
+    match protocol:
+        case EpicsProtocol.CA:
+            return CaSignalBackend
+        case EpicsProtocol.PVA:
+            return PvaSignalBackend
+
+
 def _epics_signal_backend(
     datatype: type[SignalDatatypeT] | None, read_pv: str, write_pv: str
 ) -> SignalBackend[SignalDatatypeT]:
     """Create an epics signal backend."""
-    r_protocol, r_pv = _protocol_pv(read_pv)
-    w_protocol, w_pv = _protocol_pv(write_pv)
+    r_protocol, r_pv = split_protocol_from_pv(read_pv)
+    w_protocol, w_pv = split_protocol_from_pv(write_pv)
     protocol = get_unique({read_pv: r_protocol, write_pv: w_protocol}, "protocols")
-    match protocol:
-        case EpicsProtocol.CA:
-            return CaSignalBackend(datatype, r_pv, w_pv)
-        case EpicsProtocol.PVA:
-            return PvaSignalBackend(datatype, r_pv, w_pv)
+    signal_backend_type = get_signal_backend_type(protocol)
+    return signal_backend_type(datatype, r_pv, w_pv)
 
 
 def epics_signal_rw(

ophyd_async/epics/{signal/_common.py → core/_util.py}

@@ -3,7 +3,13 @@ from typing import Any, get_args, get_origin
 
 import numpy as np
 
-from ophyd_async.core import SubsetEnum, get_dtype, get_enum_cls
+from ophyd_async.core import (
+    SignalBackend,
+    SignalDatatypeT,
+    SubsetEnum,
+    get_dtype,
+    get_enum_cls,
+)
 
 
 def get_supported_values(
@@ -41,3 +47,15 @@ def format_datatype(datatype: Any) -> str:
         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,11 +1,14 @@
+from typing import Annotated as A
+
 from ophyd_async.core import (
-    ConfigSignal,
     DeviceVector,
-    HintedSignal,
+    SignalR,
+    SignalRW,
     StandardReadable,
     StrictEnum,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 
 class EnergyMode(StrictEnum):
@@ -17,17 +20,11 @@ class EnergyMode(StrictEnum):
     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_io.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import Device, StrictEnum
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
 
 
 class EigerTriggerMode(StrictEnum):

ophyd_async/epics/eiger/_odin_io.py

@@ -15,7 +15,7 @@ from ophyd_async.core import (
     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,

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/fastcs/core.py

@@ -1,9 +1,9 @@
 from ophyd_async.core import Device, DeviceConnector
-from ophyd_async.epics.pvi import PviDeviceConnector
+from ophyd_async.epics.core import PviDeviceConnector
 
 
 def fastcs_connector(device: Device, uri: str) -> DeviceConnector:
     # TODO: add Tango support based on uri scheme
-    connector = PviDeviceConnector(uri + "PVI")
+    connector = PviDeviceConnector(uri)
     connector.create_children_from_annotations(device)
     return connector

ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,13 +1,11 @@
-from unittest.mock import Mock
-
 import bluesky.plan_stubs as bps
 
-from ophyd_async.core import DEFAULT_TIMEOUT, Device, wait_for_connection
+from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
 
 
 def ensure_connected(
     *devices: Device,
-    mock: bool | Mock = False,
+    mock: bool | LazyMock = False,
     timeout: float = DEFAULT_TIMEOUT,
     force_reconnect=False,
 ):

ophyd_async/sim/demo/_sim_motor.py

@@ -6,8 +6,6 @@ from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
-    HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
@@ -15,6 +13,7 @@ from ophyd_async.core import (
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
+from ophyd_async.core import StandardReadableFormat as Format
 
 
 class SimMotor(StandardReadable, Movable, Stoppable):
@@ -28,11 +27,11 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         - instant: bool: whether to move instantly, or with a delay
         """
         # Define some signals
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.user_readback, self._user_readback_set = soft_signal_r_and_setter(
                 float, 0
             )
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.velocity = soft_signal_rw(float, 0 if instant else 1.0)
             self.units = soft_signal_rw(str, "mm")
         self.user_setpoint = soft_signal_rw(float, 0)