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

ophyd_async/plan_stubs/_settings.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Mapping
+from typing import Any
+
+import bluesky.plan_stubs as bps
+import numpy as np
+from bluesky.utils import MsgGenerator, plan
+
+from ophyd_async.core import (
+    Device,
+    Settings,
+    SettingsProvider,
+    SignalRW,
+    T,
+    walk_rw_signals,
+)
+from ophyd_async.core._table import Table
+
+from ._wait_for_awaitable import wait_for_awaitable
+
+
+@plan
+def _get_values_of_signals(
+    signals: Mapping[T, SignalRW],
+) -> MsgGenerator[dict[T, Any]]:
+    coros = [sig.get_value() for sig in signals.values()]
+    values = yield from wait_for_awaitable(asyncio.gather(*coros))
+    named_values = dict(zip(signals, values, strict=True))
+    return named_values
+
+
+@plan
+def get_current_settings(device: Device) -> MsgGenerator[Settings]:
+    signals = walk_rw_signals(device)
+    named_values = yield from _get_values_of_signals(signals)
+    signal_values = {signals[name]: value for name, value in named_values.items()}
+    return Settings(device, signal_values)
+
+
+@plan
+def store_settings(
+    provider: SettingsProvider, name: str, device: Device
+) -> MsgGenerator[None]:
+    """Walk a Device for SignalRWs and store their values with a provider associated
+    with the given name.
+    """
+    signals = walk_rw_signals(device)
+    named_values = yield from _get_values_of_signals(signals)
+    yield from wait_for_awaitable(provider.store(name, named_values))
+
+
+@plan
+def retrieve_settings(
+    provider: SettingsProvider, name: str, device: Device
+) -> MsgGenerator[Settings]:
+    """Retrieve named Settings for a Device from a provider."""
+    named_values = yield from wait_for_awaitable(provider.retrieve(name))
+    signals = walk_rw_signals(device)
+    unknown_names = set(named_values) - set(signals)
+    if unknown_names:
+        raise NameError(f"Unknown signal names {sorted(unknown_names)}")
+    signal_values = {signals[name]: value for name, value in named_values.items()}
+    return Settings(device, signal_values)
+
+
+@plan
+def apply_settings(settings: Settings) -> MsgGenerator[None]:
+    """Set every SignalRW to the given value in Settings. If value is None ignore it."""
+    signal_values = {
+        signal: value for signal, value in settings.items() if value is not None
+    }
+    if signal_values:
+        for signal, value in signal_values.items():
+            yield from bps.abs_set(signal, value, group="apply_settings")
+        yield from bps.wait("apply_settings")
+
+
+@plan
+def apply_settings_if_different(
+    settings: Settings,
+    apply_plan: Callable[[Settings], MsgGenerator[None]],
+    current_settings: Settings | None = None,
+) -> MsgGenerator[None]:
+    """Set every SignalRW in settings to its given value if it is different to the
+    current value.
+
+    Parameters
+    ----------
+    apply_plan:
+        A device specific plan which takes the Settings to apply and applies them to
+        the Device. Used to add device specific ordering to setting the signals.
+    current_settings:
+        If given, should be a superset of settings containing the current value of
+        the Settings in the Device. If not given it will be created by reading just
+        the signals given in settings.
+    """
+    if current_settings is None:
+        # If we aren't give the current settings, then get the
+        # values of just the signals we were asked to change.
+        # This allows us to use this plan with Settings for a subset
+        # of signals in the Device without retrieving them all
+        signal_values = yield from _get_values_of_signals(
+            {sig: sig for sig in settings}
+        )
+        current_settings = Settings(settings.device, signal_values)
+
+    def _is_different(current, required) -> bool:
+        if isinstance(current, Table):
+            current = current.model_dump()
+            if isinstance(required, Table):
+                required = required.model_dump()
+            return current.keys() != required.keys() or any(
+                _is_different(current[k], required[k]) for k in current
+            )
+        elif isinstance(current, np.ndarray):
+            return not np.array_equal(current, required)
+        else:
+            return current != required
+
+    settings_to_change, _ = settings.partition(
+        lambda sig: _is_different(current_settings[sig], settings[sig])
+    )
+    yield from apply_plan(settings_to_change)

ophyd_async/plan_stubs/_wait_for_awaitable.py

@@ -0,0 +1,13 @@
+from collections.abc import Awaitable
+
+import bluesky.plan_stubs as bps
+from bluesky.utils import MsgGenerator, plan
+
+from ophyd_async.core import T
+
+
+@plan
+def wait_for_awaitable(coro: Awaitable[T]) -> MsgGenerator[T]:
+    """Wait for a single awaitable to complete, and return the result."""
+    (task,) = yield from bps.wait_for([lambda: coro])
+    return task.result()

ophyd_async/sim/__init__.py

@@ -0,0 +1,19 @@
+from ._pattern_detector import (
+    DATA_PATH,
+    SUM_PATH,
+    PatternDetector,
+    PatternDetectorController,
+    PatternDetectorWriter,
+    PatternGenerator,
+)
+from ._sim_motor import SimMotor
+
+__all__ = [
+    "DATA_PATH",
+    "SUM_PATH",
+    "PatternGenerator",
+    "PatternDetector",
+    "PatternDetectorController",
+    "PatternDetectorWriter",
+    "SimMotor",
+]

ophyd_async/sim/{demo/_pattern_detector → _pattern_detector}/_pattern_detector_controller.py

@@ -27,8 +27,15 @@ class PatternDetectorController(DetectorController):
         )
 
     async def arm(self):
-        assert self._trigger_info.livetime
-        assert self.period
+        if not hasattr(self, "_trigger_info"):
+            msg = "TriggerInfo information is missing, has 'prepare' been called?"
+            raise RuntimeError(msg)
+        if not self._trigger_info.livetime:
+            msg = "Livetime information is missing in trigger info"
+            raise ValueError(msg)
+        if not self.period:
+            msg = "Period is not set"
+            raise ValueError(msg)
         self.task = asyncio.create_task(
             self._coroutine_for_image_writing(
                 self._trigger_info.livetime,

ophyd_async/sim/{demo/_pattern_detector → _pattern_detector}/_pattern_generator.py

@@ -67,11 +67,14 @@ class PatternGenerator:
 
     def write_data_to_dataset(self, path: str, data_shape: tuple[int, ...], data):
         """Write data to named dataset, resizing to fit and flushing after."""
-        assert self._handle_for_h5_file, "no file has been opened!"
+        if not self._handle_for_h5_file:
+            msg = "No file has been opened!"
+            raise OSError(msg)
+
         dset = self._handle_for_h5_file[path]
-        assert isinstance(
-            dset, h5py.Dataset
-        ), f"Expected {path} to be dataset, got {dset}"
+        if not isinstance(dset, h5py.Dataset):
+            msg = f"Expected {path} to be a dataset, got {type(dset).__name__}"
+            raise TypeError(msg)
         dset.resize((self.image_counter + 1,) + data_shape)
         dset[self.image_counter] = data
         dset.flush()
@@ -114,7 +117,9 @@ class PatternGenerator:
 
         self._handle_for_h5_file = h5py.File(self.target_path, "w", libver="latest")
 
-        assert self._handle_for_h5_file, "not loaded the file right"
+        if not self._handle_for_h5_file:
+            msg = f"Problem opening file {self.target_path}"
+            raise OSError(msg)
 
         self._handle_for_h5_file.create_dataset(
             name=DATA_PATH,
@@ -184,7 +189,9 @@ class PatternGenerator:
             # cannot get the full filename the HDF writer will write
             # until the first frame comes in
             if not self._hdf_stream_provider:
-                assert self.target_path, "open file has not been called"
+                if self.target_path is None:
+                    msg = "open file has not been called"
+                    raise RuntimeError(msg)
                 self._hdf_stream_provider = HDFFile(
                     self.target_path,
                     self._datasets,

ophyd_async/sim/{demo/_sim_motor.py → _sim_motor.py}

@@ -2,6 +2,7 @@ import asyncio
 import contextlib
 import time
 
+import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
@@ -44,22 +45,20 @@ class SimMotor(StandardReadable, Movable, Stoppable):
 
     async def _move(self, old_position: float, new_position: float, move_time: float):
         start = time.monotonic()
-        distance = abs(new_position - old_position)
-        while True:
-            time_elapsed = round(time.monotonic() - start, 2)
-
-            # update position based on time elapsed
-            if time_elapsed >= move_time:
-                # successfully reached our target position
-                self._user_readback_set(new_position)
-                break
-            else:
-                current_position = old_position + distance * time_elapsed / move_time
-
-            self._user_readback_set(current_position)
-
-            # 10hz update loop
-            await asyncio.sleep(0.1)
+        # Make an array of relative update times at 10Hz intervals
+        update_times = np.arange(0.1, move_time, 0.1)
+        # With the end position appended
+        update_times = np.concatenate((update_times, [move_time]))
+        # Interpolate the [old, new] position array with those update times
+        new_positions = np.interp(
+            update_times, [0, move_time], [old_position, new_position]
+        )
+        for update_time, new_position in zip(update_times, new_positions, strict=True):
+            # Calculate how long to wait to get there
+            relative_time = time.monotonic() - start
+            await asyncio.sleep(update_time - relative_time)
+            # Update the readback position
+            self._user_readback_set(new_position)
 
     @WatchableAsyncStatus.wrap
     async def set(self, value: float):
@@ -75,22 +74,25 @@ class SimMotor(StandardReadable, Movable, Stoppable):
             self.velocity.get_value(),
         )
         # If zero velocity, do instant move
-        move_time = abs(new_position - old_position) / velocity if velocity else 0
-        self._move_status = AsyncStatus(
-            self._move(old_position, new_position, move_time)
-        )
-        # If stop is called then this will raise a CancelledError, ignore it
-        with contextlib.suppress(asyncio.CancelledError):
-            async for current_position in observe_value(
-                self.user_readback, done_status=self._move_status
-            ):
-                yield WatcherUpdate(
-                    current=current_position,
-                    initial=old_position,
-                    target=new_position,
-                    name=self.name,
-                    unit=units,
-                )
+        if velocity == 0:
+            self._user_readback_set(new_position)
+        else:
+            move_time = abs(new_position - old_position) / velocity
+            self._move_status = AsyncStatus(
+                self._move(old_position, new_position, move_time)
+            )
+            # If stop is called then this will raise a CancelledError, ignore it
+            with contextlib.suppress(asyncio.CancelledError):
+                async for current_position in observe_value(
+                    self.user_readback, done_status=self._move_status
+                ):
+                    yield WatcherUpdate(
+                        current=current_position,
+                        initial=old_position,
+                        target=new_position,
+                        name=self.name,
+                        unit=units,
+                    )
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
 

ophyd_async/tango/__init__.py

@@ -1,43 +0,0 @@
-from .base_devices import (
-    TangoDevice,
-    TangoReadable,
-    tango_polling,
-)
-from .signal import (
-    AttributeProxy,
-    CommandProxy,
-    TangoSignalBackend,
-    ensure_proper_executor,
-    get_dtype_extended,
-    get_python_type,
-    get_tango_trl,
-    get_trl_descriptor,
-    infer_python_type,
-    infer_signal_type,
-    make_backend,
-    tango_signal_r,
-    tango_signal_rw,
-    tango_signal_w,
-    tango_signal_x,
-)
-
-__all__ = [
-    "TangoDevice",
-    "TangoReadable",
-    "tango_polling",
-    "TangoSignalBackend",
-    "get_python_type",
-    "get_dtype_extended",
-    "get_trl_descriptor",
-    "get_tango_trl",
-    "infer_python_type",
-    "infer_signal_type",
-    "make_backend",
-    "AttributeProxy",
-    "CommandProxy",
-    "ensure_proper_executor",
-    "tango_signal_r",
-    "tango_signal_rw",
-    "tango_signal_w",
-    "tango_signal_x",
-]

ophyd_async/tango/{signal → core}/__init__.py

@@ -1,3 +1,4 @@
+from ._base_device import TangoDevice, TangoPolling
 from ._signal import (
     infer_python_type,
     infer_signal_type,
@@ -7,6 +8,7 @@ from ._signal import (
     tango_signal_w,
     tango_signal_x,
 )
+from ._tango_readable import TangoReadable
 from ._tango_transport import (
     AttributeProxy,
     CommandProxy,
@@ -18,7 +20,7 @@ from ._tango_transport import (
     get_trl_descriptor,
 )
 
-__all__ = (
+__all__ = [
     "AttributeProxy",
     "CommandProxy",
     "ensure_proper_executor",
@@ -34,4 +36,7 @@ __all__ = (
     "tango_signal_rw",
     "tango_signal_w",
     "tango_signal_x",
-)
+    "TangoDevice",
+    "TangoReadable",
+    "TangoPolling",
+]

ophyd_async/tango/{base_devices → core}/_base_device.py

@@ -1,17 +1,14 @@
 from __future__ import annotations
 
-from typing import TypeVar
-
-from ophyd_async.core import Device, DeviceConnector, DeviceFiller
-from ophyd_async.core._utils import LazyMock
-from ophyd_async.tango.signal import (
-    TangoSignalBackend,
-    infer_python_type,
-    infer_signal_type,
-)
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+from ophyd_async.core import Device, DeviceConnector, DeviceFiller, LazyMock
 from tango import DeviceProxy as DeviceProxy
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
+from ._signal import TangoSignalBackend, infer_python_type, infer_signal_type
+
 T = TypeVar("T")
 
 
@@ -32,63 +29,45 @@ class TangoDevice(Device):
 
     trl: str = ""
     proxy: DeviceProxy | None = None
-    _polling: tuple[bool, float, float | None, float | None] = (False, 0.1, None, 0.1)
-    _signal_polling: dict[str, tuple[bool, float, float, float]] = {}
-    _poll_only_annotated_signals: bool = True
 
     def __init__(
         self,
         trl: str | None = None,
         device_proxy: DeviceProxy | None = None,
+        support_events: bool = False,
         name: str = "",
     ) -> None:
         connector = TangoDeviceConnector(
-            trl=trl,
-            device_proxy=device_proxy,
-            polling=self._polling,
-            signal_polling=self._signal_polling,
+            trl=trl, device_proxy=device_proxy, support_events=support_events
         )
         super().__init__(name=name, connector=connector)
 
 
-def tango_polling(
-    polling: tuple[float, float, float]
-    | dict[str, tuple[float, float, float]]
-    | None = None,
-    signal_polling: dict[str, tuple[float, float, float]] | None = None,
-):
-    """
-    Class decorator to configure polling for Tango devices.
-
-    This decorator allows for the configuration of both device-level and signal-level
-    polling for Tango devices. Polling is useful for device servers that do not support
-    event-driven updates.
-
-    Parameters
-    ----------
-    polling : Optional[Union[Tuple[float, float, float],
-              Dict[str, Tuple[float, float, float]]]], optional
-        Device-level polling configuration as a tuple of three floats representing the
-        polling interval, polling timeout, and polling delay. Alternatively,
-        a dictionary can be provided to specify signal-level polling configurations
-        directly.
-    signal_polling : Optional[Dict[str, Tuple[float, float, float]]], optional
-        Signal-level polling configuration as a dictionary where keys are signal names
-        and values are tuples of three floats representing the polling interval, polling
-        timeout, and polling delay.
-    """
-    if isinstance(polling, dict):
-        signal_polling = polling
-        polling = None
+@dataclass
+class TangoPolling(Generic[T]):
+    ophyd_polling_period: float = 0.1
+    abs_change: T | None = None
+    rel_change: T | None = None
 
-    def decorator(cls):
-        if polling is not None:
-            cls._polling = (True, *polling)
-        if signal_polling is not None:
-            cls._signal_polling = {k: (True, *v) for k, v in signal_polling.items()}
-        return cls
 
-    return decorator
+def fill_backend_with_polling(
+    support_events: bool, backend: TangoSignalBackend, annotations: list[Any]
+):
+    unhandled = []
+    while annotations:
+        annotation = annotations.pop(0)
+        backend.allow_events(support_events)
+        if isinstance(annotation, TangoPolling):
+            backend.set_polling(
+                not support_events,
+                annotation.ophyd_polling_period,
+                annotation.abs_change,
+                annotation.rel_change,
+            )
+        else:
+            unhandled.append(annotation)
+    annotations.extend(unhandled)
+    # These leftover annotations will now be handled by the iterator
 
 
 class TangoDeviceConnector(DeviceConnector):
@@ -96,13 +75,11 @@ class TangoDeviceConnector(DeviceConnector):
         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]],
+        support_events: bool,
     ) -> None:
         self.trl = trl
         self.proxy = device_proxy
-        self._polling = polling
-        self._signal_polling = signal_polling
+        self._support_events = support_events
 
     def create_children_from_annotations(self, device: Device):
         if not hasattr(self, "filler"):
@@ -110,11 +87,14 @@ class TangoDeviceConnector(DeviceConnector):
                 device=device,
                 signal_backend_factory=TangoSignalBackend,
                 device_connector_factory=lambda: TangoDeviceConnector(
-                    None, None, (False, 0.1, None, None), {}
+                    None, None, self._support_events
                 ),
             )
             list(self.filler.create_devices_from_annotations(filled=False))
-            list(self.filler.create_signals_from_annotations(filled=False))
+            for backend, annotations in self.filler.create_signals_from_annotations(
+                filled=False
+            ):
+                fill_backend_with_polling(self._support_events, backend, annotations)
             self.filler.check_created()
 
     async def connect_mock(self, device: Device, mock: LazyMock):
@@ -145,12 +125,6 @@ class TangoDeviceConnector(DeviceConnector):
                 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

ophyd_async/tango/{signal → core}/_signal.py

@@ -16,11 +16,20 @@ from ophyd_async.core import (
     SignalW,
     SignalX,
 )
-from tango import AttrDataFormat, AttrWriteType, CmdArgType, DeviceProxy, DevState
+from tango import (
+    AttrDataFormat,
+    AttrWriteType,
+    CmdArgType,
+    DeviceProxy,
+    DevState,
+    NonSupportedFeature,  # type: ignore
+)
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
 from ._tango_transport import TangoSignalBackend, get_python_type
 
+logger = logging.getLogger("ophyd_async")
+
 
 def make_backend(
     datatype: type[SignalDatatypeT] | None,
@@ -174,8 +183,11 @@ async def infer_signal_type(
     else:
         dev_proxy = proxy
 
-    if tr_name in dev_proxy.get_pipe_list():
-        raise NotImplementedError("Pipes are not supported")
+    try:
+        if tr_name in dev_proxy.get_pipe_list():
+            raise NotImplementedError("Pipes are not supported")
+    except NonSupportedFeature:  # type: ignore
+        pass
 
     if tr_name not in dev_proxy.get_attribute_list():
         if tr_name not in dev_proxy.get_command_list():
@@ -195,7 +207,7 @@ async def infer_signal_type(
         if config.in_type == CmdArgType.DevVoid:
             return SignalX
         elif config.in_type != config.out_type:
-            logging.debug("Commands with different in and out dtypes are not supported")
+            logger.debug("Commands with different in and out dtypes are not supported")
             return None
         else:
             return SignalRW

ophyd_async/tango/{base_devices → core}/_tango_readable.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from ophyd_async.core import (
-    StandardReadable,
-)
-from ophyd_async.tango.base_devices._base_device import TangoDevice
+from ophyd_async.core import StandardReadable
 from tango import DeviceProxy
 
+from ._base_device import TangoDevice
+
 
 class TangoReadable(TangoDevice, StandardReadable):
     """

ophyd_async/tango/{signal → core}/_tango_transport.py

@@ -189,7 +189,7 @@ class AttributeProxy(TangoProxy):
                 raise TimeoutError(f"{self._name} attr put failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(
-                    f"{self._name} device" f" failure: {de.args[0].desc}"
+                    f"{self._name} device failure: {de.args[0].desc}"
                 ) from de
 
         else:
@@ -210,11 +210,11 @@ class AttributeProxy(TangoProxy):
                             await asyncio.sleep(A_BIT)
                             if to and (time.time() - start_time > to):
                                 raise TimeoutError(
-                                    f"{self._name} attr put failed:" f" Timeout"
+                                    f"{self._name} attr put failed: Timeout"
                                 ) from exc
                         else:
                             raise RuntimeError(
-                                f"{self._name} device failure:" f" {exc.args[0].desc}"
+                                f"{self._name} device failure: {exc.args[0].desc}"
                             ) from exc
 
             return AsyncStatus(wait_for_reply(rid, timeout))
@@ -422,7 +422,7 @@ class CommandProxy(TangoProxy):
                 raise TimeoutError(f"{self._name} command failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(
-                    f"{self._name} device" f" failure: {de.args[0].desc}"
+                    f"{self._name} device failure: {de.args[0].desc}"
                 ) from de
 
         else:
@@ -446,8 +446,7 @@ class CommandProxy(TangoProxy):
                                 ) from de_exc
                         else:
                             raise RuntimeError(
-                                f"{self._name} device failure:"
-                                f" {de_exc.args[0].desc}"
+                                f"{self._name} device failure: {de_exc.args[0].desc}"
                             ) from de_exc
 
             return AsyncStatus(wait_for_reply(rid, timeout))
@@ -733,22 +732,21 @@ class TangoSignalBackend(SignalBackend[SignalDatatypeT]):
                 " for which polling is disabled."
             )
 
+        if callback and self.proxies[self.read_trl].has_subscription():  # type: ignore
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.proxies[self.read_trl].has_subscription():  # type: ignore
+            self.proxies[self.read_trl].unsubscribe_callback()  # type: ignore
+
         if callback:
             try:
-                assert not self.proxies[self.read_trl].has_subscription()  # type: ignore
                 self.proxies[self.read_trl].subscribe_callback(callback)  # type: ignore
-            except AssertionError as ae:
-                raise RuntimeError(
-                    "Cannot set a callback when one" " is already set"
-                ) from ae
             except RuntimeError as exc:
                 raise RuntimeError(
-                    f"Cannot set callback" f" for {self.read_trl}. {exc}"
+                    f"Cannot set callback for {self.read_trl}. {exc}"
                 ) from exc
 
-        else:
-            self.proxies[self.read_trl].unsubscribe_callback()  # type: ignore
-
     def set_polling(
         self,
         allow_polling: bool = True,