ophyd-async 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

ophyd_async/fastcs/panda/_block.py

@@ -7,6 +7,12 @@ from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW, SubsetEnum
 from ._table import DatasetTable, SeqTable
 
 
+class CaptureMode(str, Enum):
+    FIRST_N = "FIRST_N"
+    LAST_N = "LAST_N"
+    FOREVER = "FOREVER"
+
+
 class DataBlock(Device):
     # In future we may decide to make hdf_* optional
     hdf_directory: SignalRW[str]
@@ -15,6 +21,7 @@ class DataBlock(Device):
     num_captured: SignalR[int]
     create_directory: SignalRW[int]
     directory_exists: SignalR[bool]
+    capture_mode: SignalRW[CaptureMode]
     capture: SignalRW[bool]
     flush_period: SignalRW[float]
     datasets: SignalR[DatasetTable]

ophyd_async/fastcs/panda/_control.py

@@ -1,7 +1,7 @@
 import asyncio
 
 from ophyd_async.core import (
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     wait_for_value,
 )
@@ -11,7 +11,7 @@ from ophyd_async.core._status import AsyncStatus
 from ._block import PcapBlock
 
 
-class PandaPcapController(DetectorControl):
+class PandaPcapController(DetectorController):
     def __init__(self, pcap: PcapBlock) -> None:
         self.pcap = pcap
         self._arm_status: AsyncStatus | None = None

ophyd_async/fastcs/panda/_table.py

@@ -4,7 +4,7 @@ from typing import Annotated
 
 import numpy as np
 import numpy.typing as npt
-from pydantic import Field, field_validator, model_validator
+from pydantic import Field, model_validator
 from pydantic_numpy.helper.annotation import NpArrayPydanticAnnotation
 from typing_extensions import TypedDict
 
@@ -51,13 +51,7 @@ PydanticNp1DArrayBool = Annotated[
     ),
     Field(default_factory=lambda: np.array([], dtype=np.bool_)),
 ]
-TriggerStr = Annotated[
-    np.ndarray[tuple[int], np.dtype[np.unicode_]],
-    NpArrayPydanticAnnotation.factory(
-        data_type=np.unicode_, dimensions=1, strict_data_typing=False
-    ),
-    Field(default_factory=lambda: np.array([], dtype=np.dtype("<U32"))),
-]
+TriggerStr = Annotated[Sequence[SeqTrigger], Field(default_factory=list)]
 
 
 class SeqTable(Table):
@@ -101,35 +95,7 @@ class SeqTable(Table):
         oute2: bool = False,
         outf2: bool = False,
     ) -> "SeqTable":
-        if isinstance(trigger, SeqTrigger):
-            trigger = trigger.value
-        return super().row(**locals())
-
-    @field_validator("trigger", mode="before")
-    @classmethod
-    def trigger_to_np_array(cls, trigger_column):
-        """
-        The user can provide a list of SeqTrigger enum elements instead of a numpy str.
-        """
-        if isinstance(trigger_column, Sequence) and all(
-            isinstance(trigger, SeqTrigger) for trigger in trigger_column
-        ):
-            trigger_column = np.array(
-                [trigger.value for trigger in trigger_column], dtype=np.dtype("<U32")
-            )
-        elif isinstance(trigger_column, Sequence) or isinstance(
-            trigger_column, np.ndarray
-        ):
-            for trigger in trigger_column:
-                SeqTrigger(
-                    trigger
-                )  # To check all the given strings are actually `SeqTrigger`s
-        else:
-            raise ValueError(
-                "Expected a numpy array or a sequence of `SeqTrigger`, got "
-                f"{type(trigger_column)}."
-            )
-        return trigger_column
+        return Table.row(**locals())
 
     @model_validator(mode="after")
     def validate_max_length(self) -> "SeqTable":

ophyd_async/fastcs/panda/_trigger.py

@@ -2,7 +2,7 @@ import asyncio
 
 from pydantic import BaseModel, Field
 
-from ophyd_async.core import TriggerLogic, wait_for_value
+from ophyd_async.core import FlyerController, wait_for_value
 
 from ._block import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
 from ._table import SeqTable
@@ -14,7 +14,7 @@ class SeqTableInfo(BaseModel):
     prescale_as_us: float = Field(default=1, ge=0)  # microseconds
 
 
-class StaticSeqTableTriggerLogic(TriggerLogic[SeqTableInfo]):
+class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
     def __init__(self, seq: SeqBlock) -> None:
         self.seq = seq
 
@@ -63,7 +63,7 @@ class PcompInfo(BaseModel):
     )
 
 
-class StaticPcompTriggerLogic(TriggerLogic[PcompInfo]):
+class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
     def __init__(self, pcomp: PcompBlock) -> None:
         self.pcomp = pcomp
 

ophyd_async/fastcs/panda/_writer.py

@@ -17,7 +17,7 @@ from ophyd_async.core import (
     wait_for_value,
 )
 
-from ._block import DataBlock
+from ._block import CaptureMode, DataBlock
 
 
 class PandaHDFWriter(DetectorWriter):
@@ -58,7 +58,7 @@ class PandaHDFWriter(DetectorWriter):
             self.panda_data_block.hdf_file_name.set(
                 f"{info.filename}.h5",
             ),
-            self.panda_data_block.num_capture.set(0),
+            self.panda_data_block.capture_mode.set(CaptureMode.FOREVER),
         )
 
         # Make sure that directory exists or has been created.

ophyd_async/plan_stubs/_fly.py

@@ -44,7 +44,6 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     repeats: int = 1,
     period: float = 0.0,
     frame_timeout: float | None = None,
-    iteration: int = 1,
 ):
     """Prepare a hardware triggered flyable and one or more detectors.
 
@@ -62,12 +61,11 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     deadtime = max(det.controller.get_deadtime(exposure) for det in detectors)
 
     trigger_info = TriggerInfo(
-        number=number_of_frames * repeats,
+        number_of_triggers=number_of_frames * repeats,
         trigger=DetectorTrigger.constant_gate,
         deadtime=deadtime,
         livetime=exposure,
         frame_timeout=frame_timeout,
-        iteration=iteration,
     )
     trigger_time = number_of_frames * (exposure + deadtime)
     pre_delay = max(period - 2 * shutter_time - trigger_time, 0)

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py

@@ -1,12 +1,12 @@
 import asyncio
 
-from ophyd_async.core import DetectorControl, PathProvider
+from ophyd_async.core import DetectorController, PathProvider
 from ophyd_async.core._detector import TriggerInfo
 
 from ._pattern_generator import PatternGenerator
 
 
-class PatternDetectorController(DetectorControl):
+class PatternDetectorController(DetectorController):
     def __init__(
         self,
         pattern_generator: PatternGenerator,
@@ -32,7 +32,9 @@ class PatternDetectorController(DetectorControl):
         assert self.period
         self.task = asyncio.create_task(
             self._coroutine_for_image_writing(
-                self._trigger_info.livetime, self.period, self._trigger_info.number
+                self._trigger_info.livetime,
+                self.period,
+                self._trigger_info.total_number_of_triggers,
             )
         )
 

ophyd_async/tango/__init__.py

@@ -0,0 +1,45 @@
+from .base_devices import (
+    TangoDevice,
+    TangoReadable,
+    tango_polling,
+)
+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,
+    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_character",
+    "make_backend",
+    "AttributeProxy",
+    "CommandProxy",
+    "ensure_proper_executor",
+    "__tango_signal_auto",
+    "tango_signal_r",
+    "tango_signal_rw",
+    "tango_signal_w",
+    "tango_signal_x",
+]

ophyd_async/tango/base_devices/__init__.py

@@ -0,0 +1,4 @@
+from ._base_device import TangoDevice, tango_polling
+from ._tango_readable import TangoReadable
+
+__all__ = ["TangoDevice", "TangoReadable", "tango_polling"]

ophyd_async/tango/base_devices/_base_device.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+from typing import (
+    TypeVar,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    Device,
+    Signal,
+)
+from ophyd_async.tango.signal import (
+    TangoSignalBackend,
+    __tango_signal_auto,
+    make_backend,
+)
+from tango import DeviceProxy as DeviceProxy
+from tango.asyncio import DeviceProxy as AsyncDeviceProxy
+
+T = TypeVar("T")
+
+
+class TangoDevice(Device):
+    """
+    General class for TangoDevices. Extends Device to provide attributes for Tango
+    devices.
+
+    Parameters
+    ----------
+    trl: str
+        Tango resource locator, typically of the device server.
+    device_proxy: Optional[Union[AsyncDeviceProxy, SyncDeviceProxy]]
+        Asynchronous or synchronous DeviceProxy object for the device. If not provided,
+        an asynchronous DeviceProxy object will be created using the trl and awaited
+        when the device is connected.
+    """
+
+    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,
+        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
+
+
+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
+
+    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 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

ophyd_async/tango/base_devices/_tango_readable.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.tango.base_devices._base_device import TangoDevice
+from tango import DeviceProxy
+
+
+class TangoReadable(TangoDevice, StandardReadable):
+    """
+    General class for readable TangoDevices. Extends StandardReadable to provide
+    attributes for Tango devices.
+
+    Usage: to proper signals mount should be awaited:
+    new_device = await TangoDevice(<tango_device>)
+
+    Attributes
+    ----------
+    trl : str
+        Tango resource locator, typically of the device server.
+    proxy : AsyncDeviceProxy
+        AsyncDeviceProxy object for the device. This is created when the
+        device is connected.
+    """
+
+    def __init__(
+        self,
+        trl: str | None = None,
+        device_proxy: DeviceProxy | None = None,
+        name: str = "",
+    ) -> None:
+        TangoDevice.__init__(self, trl, device_proxy=device_proxy, name=name)

ophyd_async/tango/demo/__init__.py

@@ -0,0 +1,12 @@
+from ._counter import TangoCounter
+from ._detector import TangoDetector
+from ._mover import TangoMover
+from ._tango import DemoCounter, DemoMover
+
+__all__ = [
+    "DemoCounter",
+    "DemoMover",
+    "TangoCounter",
+    "TangoMover",
+    "TangoDetector",
+]

ophyd_async/tango/demo/_counter.py

@@ -0,0 +1,37 @@
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    ConfigSignal,
+    HintedSignal,
+    SignalR,
+    SignalRW,
+    SignalX,
+)
+from ophyd_async.tango import TangoReadable, tango_polling
+
+
+# Enable device level polling, useful for servers that do not support events
+# Polling for individual signal can be enabled with a dict
+@tango_polling({"counts": (1.0, 0.1, 0.1), "sample_time": (0.1, 0.1, 0.1)})
+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]
+    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()
+        timeout = sample_time + DEFAULT_TIMEOUT
+        await self.start.trigger(wait=True, timeout=timeout)
+
+    @AsyncStatus.wrap
+    async def reset(self) -> None:
+        await self._reset.trigger(wait=True, timeout=DEFAULT_TIMEOUT)

ophyd_async/tango/demo/_detector.py

@@ -0,0 +1,42 @@
+import asyncio
+
+from ophyd_async.core import (
+    AsyncStatus,
+    DeviceVector,
+    StandardReadable,
+)
+
+from ._counter import TangoCounter
+from ._mover import TangoMover
+
+
+class TangoDetector(StandardReadable):
+    def __init__(self, mover_trl: str, counter_trls: list[str], name=""):
+        # A detector device may be composed of tango sub-devices
+        self.mover = TangoMover(mover_trl)
+        self.counters = DeviceVector(
+            {i + 1: TangoCounter(c_trl) for i, c_trl in enumerate(counter_trls)}
+        )
+
+        # Define the readables for TangoDetector
+        # DeviceVectors are incompatible with AsyncReadable. Ignore until fixed.
+        self.add_readables([self.counters, self.mover])  # type: ignore
+
+        super().__init__(name=name)
+
+    def set(self, value):
+        return self.mover.set(value)
+
+    def stop(self, success: bool = True) -> AsyncStatus:
+        return self.mover.stop(success)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        statuses = []
+        for counter in self.counters.values():
+            statuses.append(counter.reset())
+        await asyncio.gather(*statuses)
+        statuses.clear()
+        for counter in self.counters.values():
+            statuses.append(counter.trigger())
+        await asyncio.gather(*statuses)

ophyd_async/tango/demo/_mover.py

@@ -0,0 +1,77 @@
+import asyncio
+
+from bluesky.protocols import Movable, Stoppable
+
+from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    CalculatableTimeout,
+    ConfigSignal,
+    HintedSignal,
+    SignalR,
+    SignalRW,
+    SignalX,
+    WatchableAsyncStatus,
+    WatcherUpdate,
+    observe_value,
+    wait_for_value,
+)
+from ophyd_async.tango import TangoReadable, tango_polling
+from tango import DevState
+
+
+# Enable device level polling, useful for servers that do not support events
+@tango_polling((0.1, 0.1, 0.1))
+class TangoMover(TangoReadable, Movable, Stoppable):
+    # 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
+    position: SignalRW[float]
+    velocity: SignalRW[float]
+    state: SignalR[DevState]
+    _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._set_success = True
+
+    @WatchableAsyncStatus.wrap
+    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
+        self._set_success = True
+        (old_position, velocity) = await asyncio.gather(
+            self.position.get_value(), self.velocity.get_value()
+        )
+        if timeout is CALCULATE_TIMEOUT:
+            assert velocity > 0, "Motor has zero velocity"
+            timeout = abs(value - old_position) / velocity + DEFAULT_TIMEOUT
+
+        if not (isinstance(timeout, float) or timeout is None):
+            raise ValueError("Timeout must be a float or None")
+        # For this server, set returns immediately so this status should not be awaited
+        await self.position.set(value, wait=False, timeout=timeout)
+
+        move_status = AsyncStatus(
+            wait_for_value(self.state, DevState.ON, timeout=timeout)
+        )
+
+        try:
+            async for current_position in observe_value(
+                self.position, done_status=move_status
+            ):
+                yield WatcherUpdate(
+                    current=current_position,
+                    initial=old_position,
+                    target=value,
+                    name=self.name,
+                )
+        except RuntimeError as exc:
+            self._set_success = False
+            raise RuntimeError("Motor was stopped") from exc
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
+
+    def stop(self, success: bool = True) -> AsyncStatus:
+        self._set_success = success
+        return self._stop.trigger()

ophyd_async/tango/demo/_tango/__init__.py

@@ -0,0 +1,3 @@
+from ._servers import DemoCounter, DemoMover
+
+__all__ = ["DemoCounter", "DemoMover"]