ophyd-async 0.7.0a1__py3-none-any.whl → 0.8.0a3__py3-none-any.whl

ophyd_async/plan_stubs/_ensure_connected.py

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

ophyd_async/plan_stubs/_fly.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     in_micros,
 )
 from ophyd_async.fastcs.panda import (
-    PcompDirectionOptions,
+    PcompDirection,
     PcompInfo,
     SeqTable,
     SeqTableInfo,
@@ -147,7 +147,7 @@ def fly_and_collect_with_static_pcomp(
     number_of_pulses: int,
     pulse_width: int,
     rising_edge_step: int,
-    direction: PcompDirectionOptions,
+    direction: PcompDirection,
     trigger_info: TriggerInfo,
 ):
     # Set up scan and prepare trigger

ophyd_async/plan_stubs/_nd_attributes.py

@@ -16,12 +16,12 @@ from ophyd_async.epics.adcore import (
 def setup_ndattributes(
     device: NDArrayBaseIO, ndattributes: Sequence[NDAttributePv | NDAttributeParam]
 ):
-    xml_text = ET.Element("Attributes")
+    root = ET.Element("Attributes")
 
     for ndattribute in ndattributes:
         if isinstance(ndattribute, NDAttributeParam):
             ET.SubElement(
-                xml_text,
+                root,
                 "Attribute",
                 name=ndattribute.name,
                 type="PARAM",
@@ -32,7 +32,7 @@ def setup_ndattributes(
             )
         elif isinstance(ndattribute, NDAttributePv):
             ET.SubElement(
-                xml_text,
+                root,
                 "Attribute",
                 name=ndattribute.name,
                 type="EPICS_PV",
@@ -45,7 +45,8 @@ def setup_ndattributes(
                 f"Invalid type for ndattributes: {type(ndattribute)}. "
                 "Expected NDAttributePv or NDAttributeParam."
             )
-    yield from bps.mv(device.nd_attributes_file, xml_text)
+    xml_text = ET.tostring(root, encoding="unicode")
+    yield from bps.abs_set(device.nd_attributes_file, xml_text, wait=True)
 
 
 def setup_ndstats_sum(detector: Device):

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py

@@ -1,7 +1,6 @@
 import asyncio
 
-from ophyd_async.core import DetectorController, PathProvider
-from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core import DetectorController, PathProvider, TriggerInfo
 
 from ._pattern_generator import PatternGenerator
 

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/__init__.py

@@ -7,14 +7,13 @@ from .signal import (
     AttributeProxy,
     CommandProxy,
     TangoSignalBackend,
-    __tango_signal_auto,
     ensure_proper_executor,
     get_dtype_extended,
     get_python_type,
     get_tango_trl,
     get_trl_descriptor,
     infer_python_type,
-    infer_signal_character,
+    infer_signal_type,
     make_backend,
     tango_signal_r,
     tango_signal_rw,
@@ -32,12 +31,11 @@ __all__ = [
     "get_trl_descriptor",
     "get_tango_trl",
     "infer_python_type",
-    "infer_signal_character",
+    "infer_signal_type",
     "make_backend",
     "AttributeProxy",
     "CommandProxy",
     "ensure_proper_executor",
-    "__tango_signal_auto",
     "tango_signal_r",
     "tango_signal_rw",
     "tango_signal_w",

ophyd_async/tango/base_devices/_base_device.py

@@ -1,21 +1,13 @@
 from __future__ import annotations
 
-from typing import (
-    TypeVar,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
+from typing import TypeVar
+from unittest.mock import Mock
 
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    Device,
-    Signal,
-)
+from ophyd_async.core import Device, DeviceConnector, DeviceFiller
 from ophyd_async.tango.signal import (
     TangoSignalBackend,
-    __tango_signal_auto,
-    make_backend,
+    infer_python_type,
+    infer_signal_type,
 )
 from tango import DeviceProxy as DeviceProxy
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
@@ -50,64 +42,13 @@ class TangoDevice(Device):
         device_proxy: DeviceProxy | None = None,
         name: str = "",
     ) -> None:
-        self.trl = trl if trl else ""
-        self.proxy = device_proxy
-        tango_create_children_from_annotations(self)
-        super().__init__(name=name)
-
-    def set_trl(self, trl: str):
-        """Set the Tango resource locator."""
-        if not isinstance(trl, str):
-            raise ValueError("TRL must be a string.")
-        self.trl = trl
-
-    async def connect(
-        self,
-        mock: bool = False,
-        timeout: float = DEFAULT_TIMEOUT,
-        force_reconnect: bool = False,
-    ):
-        if self.trl and self.proxy is None:
-            self.proxy = await AsyncDeviceProxy(self.trl)
-        elif self.proxy and not self.trl:
-            self.trl = self.proxy.name()
-
-        # Set the trl of the signal backends
-        for child in self.children():
-            if isinstance(child[1], Signal):
-                if isinstance(child[1]._backend, TangoSignalBackend):  # noqa: SLF001
-                    resource_name = child[0].lstrip("_")
-                    read_trl = f"{self.trl}/{resource_name}"
-                    child[1]._backend.set_trl(read_trl, read_trl)  # noqa: SLF001
-
-        if self.proxy is not None:
-            self.register_signals()
-            await _fill_proxy_entries(self)
-
-        # set_name should be called again to propagate the new signal names
-        self.set_name(self.name)
-
-        # Set the polling configuration
-        if self._polling[0]:
-            for child in self.children():
-                child_type = type(child[1])
-                if issubclass(child_type, Signal):
-                    if isinstance(child[1]._backend, TangoSignalBackend):  # noqa: SLF001  # type: ignore
-                        child[1]._backend.set_polling(*self._polling)  # noqa: SLF001  # type: ignore
-                        child[1]._backend.allow_events(False)  # noqa: SLF001  # type: ignore
-        if self._signal_polling:
-            for signal_name, polling in self._signal_polling.items():
-                if hasattr(self, signal_name):
-                    attr = getattr(self, signal_name)
-                    if isinstance(attr._backend, TangoSignalBackend):  # noqa: SLF001
-                        attr._backend.set_polling(*polling)  # noqa: SLF001
-                        attr._backend.allow_events(False)  # noqa: SLF001
-
-        await super().connect(mock=mock, timeout=timeout)
-
-    # Users can override this method to register new signals
-    def register_signals(self):
-        pass
+        connector = TangoDeviceConnector(
+            trl=trl,
+            device_proxy=device_proxy,
+            polling=self._polling,
+            signal_polling=self._signal_polling,
+        )
+        super().__init__(name=name, connector=connector)
 
 
 def tango_polling(
@@ -150,76 +91,67 @@ def tango_polling(
     return decorator
 
 
-def tango_create_children_from_annotations(
-    device: TangoDevice, included_optional_fields: tuple[str, ...] = ()
-):
-    """Initialize blocks at __init__ of `device`."""
-    for name, device_type in get_type_hints(type(device)).items():
-        if name in ("_name", "parent"):
-            continue
-
-        # device_type, is_optional = _strip_union(device_type)
-        # if is_optional and name not in included_optional_fields:
-        #     continue
-        #
-        # is_device_vector, device_type = _strip_device_vector(device_type)
-        # if is_device_vector:
-        #     n_device_vector = DeviceVector()
-        #     setattr(device, name, n_device_vector)
-
-        # else:
-        origin = get_origin(device_type)
-        origin = origin if origin else device_type
-
-        if issubclass(origin, Signal):
-            type_args = get_args(device_type)
-            datatype = type_args[0] if type_args else None
-            backend = make_backend(datatype=datatype, device_proxy=device.proxy)
-            setattr(device, name, origin(name=name, backend=backend))
-
-        elif issubclass(origin, Device) or isinstance(origin, Device):
-            assert callable(origin), f"{origin} is not callable."
-            setattr(device, name, origin())
-
-
-async def _fill_proxy_entries(device: TangoDevice):
-    if device.proxy is None:
-        raise RuntimeError(f"Device proxy is not connected for {device.name}")
-    proxy_trl = device.trl
-    children = [name.lstrip("_") for name, _ in device.children()]
-    proxy_attributes = list(device.proxy.get_attribute_list())
-    proxy_commands = list(device.proxy.get_command_list())
-    combined = proxy_attributes + proxy_commands
-
-    for name in combined:
-        if name not in children:
-            full_trl = f"{proxy_trl}/{name}"
-            try:
-                auto_signal = await __tango_signal_auto(
-                    trl=full_trl, device_proxy=device.proxy
-                )
-                setattr(device, name, auto_signal)
-            except RuntimeError as e:
-                if "Commands with different in and out dtypes" in str(e):
-                    print(
-                        f"Skipping {name}. Commands with different in and out dtypes"
-                        f" are not supported."
-                    )
-                    continue
-                raise e
-
-
-# def _strip_union(field: T | T) -> tuple[T, bool]:
-#     if get_origin(field) is Union:
-#         args = get_args(field)
-#         is_optional = type(None) in args
-#         for arg in args:
-#             if arg is not type(None):
-#                 return arg, is_optional
-#     return field, False
-#
-#
-# def _strip_device_vector(field: type[Device]) -> tuple[bool, type[Device]]:
-#     if get_origin(field) is DeviceVector:
-#         return True, get_args(field)[0]
-#     return False, field
+class TangoDeviceConnector(DeviceConnector):
+    def __init__(
+        self,
+        trl: str | None,
+        device_proxy: DeviceProxy | None,
+        polling: tuple[bool, float, float | None, float | None],
+        signal_polling: dict[str, tuple[bool, float, float, float]],
+    ) -> None:
+        self.trl = trl
+        self.proxy = device_proxy
+        self._polling = polling
+        self._signal_polling = signal_polling
+
+    def create_children_from_annotations(self, device: Device):
+        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.create_device_vector_entries_to_mock(2)
+        else:
+            if self.trl and self.proxy is None:
+                self.proxy = await AsyncDeviceProxy(self.trl)
+            elif self.proxy and not self.trl:
+                self.trl = self.proxy.name()
+            else:
+                raise TypeError("Neither proxy nor trl supplied")
+
+            children = sorted(
+                set()
+                .union(self.proxy.get_attribute_list())
+                .union(self.proxy.get_command_list())
+            )
+            for name in children:
+                # TODO: strip attribute name
+                full_trl = f"{self.trl}/{name}"
+                signal_type = await infer_signal_type(full_trl, self.proxy)
+                if 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, ()):
+                        backend.set_polling(*polling)
+                        backend.allow_events(False)
+                    elif self._polling[0]:
+                        backend.set_polling(*self._polling)
+                        backend.allow_events(False)
+            # 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,15 +11,10 @@ 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)
+    reset_: SignalX
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
@@ -34,4 +24,4 @@ class TangoCounter(TangoReadable):
 
     @AsyncStatus.wrap
     async def reset(self) -> None:
-        await self._reset.trigger(wait=True, timeout=DEFAULT_TIMEOUT)
+        await self.reset_.trigger(wait=True, timeout=DEFAULT_TIMEOUT)

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
 
@@ -29,12 +28,12 @@ class TangoMover(TangoReadable, Movable, Stoppable):
     position: SignalRW[float]
     velocity: SignalRW[float]
     state: SignalR[DevState]
-    _stop: SignalX
+    stop_: SignalX
 
     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
@@ -74,4 +73,4 @@ class TangoMover(TangoReadable, Movable, Stoppable):
 
     def stop(self, success: bool = True) -> AsyncStatus:
         self._set_success = success
-        return self._stop.trigger()
+        return self.stop_.trigger()

ophyd_async/tango/signal/__init__.py

@@ -1,7 +1,6 @@
 from ._signal import (
-    __tango_signal_auto,
     infer_python_type,
-    infer_signal_character,
+    infer_signal_type,
     make_backend,
     tango_signal_r,
     tango_signal_rw,
@@ -29,11 +28,10 @@ __all__ = (
     "get_trl_descriptor",
     "get_tango_trl",
     "infer_python_type",
-    "infer_signal_character",
+    "infer_signal_type",
     "make_backend",
     "tango_signal_r",
     "tango_signal_rw",
     "tango_signal_w",
     "tango_signal_x",
-    "__tango_signal_auto",
 )

ophyd_async/tango/signal/_signal.py

@@ -2,21 +2,28 @@
 
 from __future__ import annotations
 
+import logging
 from enum import Enum, IntEnum
 
 import numpy.typing as npt
 
-from ophyd_async.core import DEFAULT_TIMEOUT, SignalR, SignalRW, SignalW, SignalX, T
-from ophyd_async.tango.signal._tango_transport import (
-    TangoSignalBackend,
-    get_python_type,
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    Signal,
+    SignalDatatypeT,
+    SignalR,
+    SignalRW,
+    SignalW,
+    SignalX,
 )
 from tango import AttrDataFormat, AttrWriteType, CmdArgType, DeviceProxy, DevState
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
+from ._tango_transport import TangoSignalBackend, get_python_type
+
 
 def make_backend(
-    datatype: type[T] | None,
+    datatype: type[SignalDatatypeT] | None,
     read_trl: str = "",
     write_trl: str = "",
     device_proxy: DeviceProxy | None = None,
@@ -25,13 +32,13 @@ def make_backend(
 
 
 def tango_signal_rw(
-    datatype: type[T],
+    datatype: type[SignalDatatypeT],
     read_trl: str,
     write_trl: str = "",
     device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
-) -> SignalRW[T]:
+) -> SignalRW[SignalDatatypeT]:
     """Create a `SignalRW` backed by 1 or 2 Tango Attribute/Command
 
     Parameters
@@ -54,12 +61,12 @@ def tango_signal_rw(
 
 
 def tango_signal_r(
-    datatype: type[T],
+    datatype: type[SignalDatatypeT],
     read_trl: str,
     device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
-) -> SignalR[T]:
+) -> SignalR[SignalDatatypeT]:
     """Create a `SignalR` backed by 1 Tango Attribute/Command
 
     Parameters
@@ -80,12 +87,12 @@ def tango_signal_r(
 
 
 def tango_signal_w(
-    datatype: type[T],
+    datatype: type[SignalDatatypeT],
     write_trl: str,
     device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
-) -> SignalW[T]:
+) -> SignalW[SignalDatatypeT]:
     """Create a `SignalW` backed by 1 Tango Attribute/Command
 
     Parameters
@@ -128,39 +135,10 @@ def tango_signal_x(
     return SignalX(backend, timeout=timeout, name=name)
 
 
-async def __tango_signal_auto(
-    datatype: type[T] | None = None,
-    *,
-    trl: str,
-    device_proxy: DeviceProxy | None,
-    timeout: float = DEFAULT_TIMEOUT,
-    name: str = "",
-) -> SignalW | SignalX | SignalR | SignalRW | None:
-    try:
-        signal_character = await infer_signal_character(trl, device_proxy)
-    except RuntimeError as e:
-        if "Commands with different in and out dtypes" in str(e):
-            return None
-        else:
-            raise e
-
-    if datatype is None:
-        datatype = await infer_python_type(trl, device_proxy)
-
-    backend = make_backend(datatype, trl, trl, device_proxy)
-    if signal_character == "RW":
-        return SignalRW(backend=backend, timeout=timeout, name=name)
-    if signal_character == "R":
-        return SignalR(backend=backend, timeout=timeout, name=name)
-    if signal_character == "W":
-        return SignalW(backend=backend, timeout=timeout, name=name)
-    if signal_character == "X":
-        return SignalX(backend=backend, timeout=timeout, name=name)
-
-
 async def infer_python_type(
     trl: str = "", proxy: DeviceProxy | None = None
 ) -> object | npt.NDArray | type[DevState] | IntEnum:
+    # TODO: work out if this is still needed
     device_trl, tr_name = trl.rsplit("/", 1)
     if proxy is None:
         dev_proxy = await AsyncDeviceProxy(device_trl)
@@ -187,7 +165,9 @@ async def infer_python_type(
     return npt.NDArray[py_type] if isarray else py_type
 
 
-async def infer_signal_character(trl, proxy: DeviceProxy | None = None) -> str:
+async def infer_signal_type(
+    trl, proxy: DeviceProxy | None = None
+) -> type[Signal] | None:
     device_trl, tr_name = trl.rsplit("/", 1)
     if proxy is None:
         dev_proxy = await AsyncDeviceProxy(device_trl)
@@ -204,20 +184,19 @@ async def infer_signal_character(trl, proxy: DeviceProxy | None = None) -> str:
     if tr_name in dev_proxy.get_attribute_list():
         config = await dev_proxy.get_attribute_config(tr_name)
         if config.writable in [AttrWriteType.READ_WRITE, AttrWriteType.READ_WITH_WRITE]:
-            return "RW"
+            return SignalRW
         elif config.writable == AttrWriteType.READ:
-            return "R"
+            return SignalR
         else:
-            return "W"
+            return SignalW
 
     if tr_name in dev_proxy.get_command_list():
         config = await dev_proxy.get_command_config(tr_name)
         if config.in_type == CmdArgType.DevVoid:
-            return "X"
+            return SignalX
         elif config.in_type != config.out_type:
-            raise RuntimeError(
-                "Commands with different in and out dtypes are not" " supported"
-            )
+            logging.debug("Commands with different in and out dtypes are not supported")
+            return None
         else:
-            return "RW"
+            return SignalRW
     raise RuntimeError(f"Unable to infer signal character for {trl}")