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

ophyd_async/epics/core/_pvi_connector.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from unittest.mock import Mock
+
+from ophyd_async.core import (
+    Device,
+    DeviceConnector,
+    DeviceFiller,
+    Signal,
+    SignalR,
+    SignalRW,
+    SignalX,
+)
+
+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(
+        self, device: Device, mock: bool | Mock, timeout: float, force_reconnect: bool
+    ) -> None:
+        if mock:
+            # Make 2 entries for each DeviceVector
+            self.filler.create_device_vector_entries_to_mock(2)
+        else:
+            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(device, mock, 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/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)

ophyd_async/tango/base_devices/_base_device.py

@@ -48,7 +48,6 @@ class TangoDevice(Device):
             polling=self._polling,
             signal_polling=self._signal_polling,
         )
-        connector.create_children_from_annotations(self)
         super().__init__(name=name, connector=connector)
 
 
@@ -106,20 +105,24 @@ class TangoDeviceConnector(DeviceConnector):
         self._signal_polling = signal_polling
 
     def create_children_from_annotations(self, device: Device):
-        self._filler = DeviceFiller(
-            device=device,
-            signal_backend_factory=TangoSignalBackend,
-            device_connector_factory=lambda: TangoDeviceConnector(
-                None, None, (False, 0.1, None, None), {}
-            ),
-        )
+        if not hasattr(self, "filler"):
+            self.filler = DeviceFiller(
+                device=device,
+                signal_backend_factory=TangoSignalBackend,
+                device_connector_factory=lambda: TangoDeviceConnector(
+                    None, None, (False, 0.1, None, None), {}
+                ),
+            )
+            list(self.filler.create_devices_from_annotations(filled=False))
+            list(self.filler.create_signals_from_annotations(filled=False))
+            self.filler.check_created()
 
     async def connect(
         self, device: Device, mock: bool | Mock, timeout: float, force_reconnect: bool
     ) -> None:
         if mock:
             # Make 2 entries for each DeviceVector
-            self._filler.make_soft_device_vector_entries(2)
+            self.filler.create_device_vector_entries_to_mock(2)
         else:
             if self.trl and self.proxy is None:
                 self.proxy = await AsyncDeviceProxy(self.trl)
@@ -138,7 +141,7 @@ class TangoDeviceConnector(DeviceConnector):
                 full_trl = f"{self.trl}/{name}"
                 signal_type = await infer_signal_type(full_trl, self.proxy)
                 if signal_type:
-                    backend = self._filler.make_child_signal(name, signal_type)
+                    backend = self.filler.fill_child_signal(name, signal_type)
                     backend.datatype = await infer_python_type(full_trl, self.proxy)
                     backend.set_trl(full_trl)
                     if polling := self._signal_polling.get(name, ()):
@@ -147,12 +150,8 @@ class TangoDeviceConnector(DeviceConnector):
                     elif self._polling[0]:
                         backend.set_polling(*self._polling)
                         backend.allow_events(False)
-            # Check that all the requested children have been created
-            if unfilled := self._filler.unfilled():
-                raise RuntimeError(
-                    f"{device.name}: cannot provision {unfilled} from "
-                    f"{self.trl}: {children}"
-                )
+            # Check that all the requested children have been filled
+            self.filler.check_filled(f"{self.trl}: {children}")
         # Set the name of the device to name all children
         device.set_name(device.name)
         return await super().connect(device, mock, timeout, force_reconnect)

ophyd_async/tango/demo/_counter.py

@@ -1,12 +1,7 @@
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    AsyncStatus,
-    ConfigSignal,
-    HintedSignal,
-    SignalR,
-    SignalRW,
-    SignalX,
-)
+from typing import Annotated as A
+
+from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, SignalR, SignalRW, SignalX
+from ophyd_async.core import StandardReadableFormat as Format
 from ophyd_async.tango import TangoReadable, tango_polling
 
 
@@ -16,16 +11,11 @@ from ophyd_async.tango import TangoReadable, tango_polling
 class TangoCounter(TangoReadable):
     # Enter the name and type of the signals you want to use
     # If type is None or Signal, the type will be inferred from the Tango device
-    counts: SignalR[int]
-    sample_time: SignalRW[float]
+    counts: A[SignalR[int], Format.HINTED_SIGNAL]
+    sample_time: A[SignalRW[float], Format.CONFIG_SIGNAL]
     start: SignalX
     reset_: SignalX
 
-    def __init__(self, trl: str | None = "", name=""):
-        super().__init__(trl, name=name)
-        self.add_readables([self.counts], HintedSignal)
-        self.add_readables([self.sample_time], ConfigSignal)
-
     @AsyncStatus.wrap
     async def trigger(self) -> None:
         sample_time = await self.sample_time.get_value()

ophyd_async/tango/demo/_mover.py

@@ -7,8 +7,6 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    ConfigSignal,
-    HintedSignal,
     SignalR,
     SignalRW,
     SignalX,
@@ -17,6 +15,7 @@ from ophyd_async.core import (
     observe_value,
     wait_for_value,
 )
+from ophyd_async.core import StandardReadableFormat as Format
 from ophyd_async.tango import TangoReadable, tango_polling
 from tango import DevState
 
@@ -33,8 +32,8 @@ class TangoMover(TangoReadable, Movable, Stoppable):
 
     def __init__(self, trl: str | None = "", name=""):
         super().__init__(trl, name=name)
-        self.add_readables([self.position], HintedSignal)
-        self.add_readables([self.velocity], ConfigSignal)
+        self.add_readables([self.position], Format.HINTED_SIGNAL)
+        self.add_readables([self.velocity], Format.CONFIG_SIGNAL)
         self._set_success = True
 
     @WatchableAsyncStatus.wrap

{ophyd_async-0.8.0a2.dist-info → ophyd_async-0.8.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.8.0a2
+Version: 0.8.0a3
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License