ophyd-async 0.5.2__py3-none-any.whl → 0.7.0a1__py3-none-any.whl

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py

@@ -1,12 +1,12 @@
 import asyncio
-from typing import Optional
 
-from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger, 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,
@@ -14,36 +14,42 @@ class PatternDetectorController(DetectorControl):
         exposure: float = 0.1,
     ) -> None:
         self.pattern_generator: PatternGenerator = pattern_generator
-        if exposure is None:
-            exposure = 0.1
         self.pattern_generator.set_exposure(exposure)
         self.path_provider: PathProvider = path_provider
-        self.task: Optional[asyncio.Task] = None
+        self.task: asyncio.Task | None = None
         super().__init__()
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = 0.01,
-    ) -> AsyncStatus:
-        if exposure is None:
-            exposure = 0.1
-        period: float = exposure + self.get_deadtime(exposure)
-        task = asyncio.create_task(
-            self._coroutine_for_image_writing(exposure, period, num)
+    async def prepare(self, trigger_info: TriggerInfo):
+        self._trigger_info = trigger_info
+        if self._trigger_info.livetime is None:
+            self._trigger_info.livetime = 0.01
+        self.period: float = self._trigger_info.livetime + self.get_deadtime(
+            trigger_info.livetime
         )
-        self.task = task
-        return AsyncStatus(task)
 
-    async def disarm(self):
+    async def arm(self):
+        assert self._trigger_info.livetime
+        assert self.period
+        self.task = asyncio.create_task(
+            self._coroutine_for_image_writing(
+                self._trigger_info.livetime,
+                self.period,
+                self._trigger_info.total_number_of_triggers,
+            )
+        )
+
+    async def wait_for_idle(self):
         if self.task:
+            await self.task
+
+    async def disarm(self):
+        if self.task and not self.task.done():
             self.task.cancel()
             try:
                 await self.task
             except asyncio.CancelledError:
                 pass
-            self.task = None
+        self.task = None
 
     def get_deadtime(self, exposure: float | None) -> float:
         return 0.001

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_writer.py

@@ -1,8 +1,8 @@
-from typing import AsyncGenerator, AsyncIterator, Dict
+from collections.abc import AsyncGenerator, AsyncIterator
 
-from bluesky.protocols import DataKey
+from event_model import DataKey
 
-from ophyd_async.core import DetectorWriter, NameProvider, PathProvider
+from ophyd_async.core import DEFAULT_TIMEOUT, DetectorWriter, NameProvider, PathProvider
 
 from ._pattern_generator import PatternGenerator
 
@@ -20,7 +20,7 @@ class PatternDetectorWriter(DetectorWriter):
         self.path_provider = path_provider
         self.name_provider = name_provider
 
-    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
         return await self.pattern_generator.open_file(
             self.path_provider, self.name_provider(), multiplier
         )
@@ -31,8 +31,11 @@ class PatternDetectorWriter(DetectorWriter):
     def collect_stream_docs(self, indices_written: int) -> AsyncIterator:
         return self.pattern_generator.collect_stream_docs(indices_written)
 
-    def observe_indices_written(self, timeout=...) -> AsyncGenerator[int, None]:
-        return self.pattern_generator.observe_indices_written()
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        async for index in self.pattern_generator.observe_indices_written(timeout):
+            yield index
 
     async def get_indices_written(self) -> int:
         return self.pattern_generator.image_counter

ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py

@@ -1,9 +1,10 @@
+from collections.abc import AsyncGenerator, AsyncIterator
 from pathlib import Path
-from typing import AsyncGenerator, AsyncIterator, Dict, Optional
 
 import h5py
 import numpy as np
-from bluesky.protocols import DataKey, StreamAsset
+from bluesky.protocols import StreamAsset
+from event_model import DataKey
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -60,19 +61,22 @@ class PatternGenerator:
             generate_gaussian_blob(width=detector_width, height=detector_height)
             * MAX_UINT8_VALUE
         )
-        self._hdf_stream_provider: Optional[HDFFile] = None
-        self._handle_for_h5_file: Optional[h5py.File] = None
-        self.target_path: Optional[Path] = None
+        self._hdf_stream_provider: HDFFile | None = None
+        self._handle_for_h5_file: h5py.File | None = None
+        self.target_path: Path | None = None
 
-    async def write_image_to_file(self) -> None:
+    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!"
-        # prepare - resize the fixed hdf5 data structure
-        # so that the new image can be written
-        self._handle_for_h5_file[DATA_PATH].resize(
-            (self.image_counter + 1, self.height, self.width)
-        )
-        self._handle_for_h5_file[SUM_PATH].resize((self.image_counter + 1,))
+        dset = self._handle_for_h5_file[path]
+        assert isinstance(
+            dset, h5py.Dataset
+        ), f"Expected {path} to be dataset, got {dset}"
+        dset.resize((self.image_counter + 1,) + data_shape)
+        dset[self.image_counter] = data
+        dset.flush()
 
+    async def write_image_to_file(self) -> None:
         # generate the simulated data
         intensity: float = generate_interesting_pattern(self.x, self.y)
         detector_data = (
@@ -82,14 +86,9 @@ class PatternGenerator:
             / self.saturation_exposure_time
         ).astype(np.uint8)
 
-        # write data to disc (intermediate step)
-        self._handle_for_h5_file[DATA_PATH][self.image_counter] = detector_data
-        sum = np.sum(detector_data)
-        self._handle_for_h5_file[SUM_PATH][self.image_counter] = sum
-
-        # save metadata - so that it's discoverable
-        self._handle_for_h5_file[DATA_PATH].flush()
-        self._handle_for_h5_file[SUM_PATH].flush()
+        # Write the data and sum
+        self.write_data_to_dataset(DATA_PATH, (self.height, self.width), detector_data)
+        self.write_data_to_dataset(SUM_PATH, (), np.sum(detector_data))
 
         # counter increment is last
         # as only at this point the new data is visible from the outside
@@ -107,7 +106,7 @@ class PatternGenerator:
 
     async def open_file(
         self, path_provider: PathProvider, name: str, multiplier: int = 1
-    ) -> Dict[str, DataKey]:
+    ) -> dict[str, DataKey]:
         await self.counter_signal.connect()
 
         self.target_path = self._get_new_path(path_provider)
@@ -156,7 +155,7 @@ class PatternGenerator:
         describe = {
             ds.data_key: DataKey(
                 source="sim://pattern-generator-hdf-file",
-                shape=outer_shape + tuple(ds.shape),
+                shape=list(outer_shape) + list(ds.shape),
                 dtype="array" if ds.shape else "number",
                 external="STREAM:",
             )
@@ -199,7 +198,6 @@ class PatternGenerator:
     def close(self) -> None:
         if self._handle_for_h5_file:
             self._handle_for_h5_file.close()
-            print("file closed")
             self._handle_for_h5_file = None
 
     async def observe_indices_written(

ophyd_async/sim/demo/_sim_motor.py

@@ -63,10 +63,11 @@ class SimMotor(StandardReadable, Movable, Stoppable):
             await asyncio.sleep(0.1)
 
     @WatchableAsyncStatus.wrap
-    async def set(self, new_position: float):
+    async def set(self, value: float):
         """
         Asynchronously move the motor to a new position.
         """
+        new_position = value
         # Make sure any existing move tasks are stopped
         await self.stop()
         old_position, units, velocity = await asyncio.gather(

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)