ophyd-async 0.9.0a2__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async/sim/_pattern_generator.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+# raw data path
+DATA_PATH = "/entry/data/data"
+
+# pixel sum path
+SUM_PATH = "/entry/sum"
+
+
+def generate_gaussian_blob(height: int, width: int) -> np.ndarray:
+    """Make a Gaussian Blob with float values in range 0..1."""
+    x, y = np.meshgrid(np.linspace(-1, 1, width), np.linspace(-1, 1, height))
+    d = np.sqrt(x * x + y * y)
+    blob = np.exp(-(d**2))
+    return blob
+
+
+def generate_interesting_pattern(
+    x: float, y: float, channel: int, offset: float
+) -> float:
+    """Return a float value in range 0..1.
+
+    Interesting in x and y in range -10..10
+    """
+    return (np.sin(x) ** channel + np.cos(x * y + offset) + 2) / 4
+
+
+class PatternFile:
+    def __init__(
+        self,
+        path: Path,
+        width: int = 320,
+        height: int = 240,
+    ):
+        self.file = h5py.File(path, "w", libver="latest")
+        self.data = self.file.create_dataset(
+            name=DATA_PATH,
+            shape=(0, height, width),
+            dtype=np.uint8,
+            maxshape=(None, height, width),
+        )
+        self.sum = self.file.create_dataset(
+            name=SUM_PATH,
+            shape=(0,),
+            dtype=np.int64,
+            maxshape=(None,),
+        )
+        # Once datasets written, can switch the model to single writer multiple reader
+        self.file.swmr_mode = True
+        self.blob = generate_gaussian_blob(height, width) * np.iinfo(np.uint8).max
+        self.image_counter = 0
+        self.e = asyncio.Event()
+
+    def write_image_to_file(self, intensity: float):
+        data = np.floor(self.blob * intensity)
+        for dset, value in ((self.data, data), (self.sum, np.sum(data))):
+            dset.resize(self.image_counter + 1, axis=0)
+            dset[self.image_counter] = value
+            dset.flush()
+        self.image_counter += 1
+        self.e.set()
+        self.e.clear()
+
+    def close(self):
+        self.file.close()
+
+
+class PatternGenerator:
+    """Generates pattern images in files."""
+
+    def __init__(self, sleep=asyncio.sleep):
+        self._x = 0.0
+        self._y = 0.0
+        self._file: PatternFile | None = None
+        self.sleep = sleep
+
+    def set_x(self, x: float):
+        self._x = x
+
+    def set_y(self, y: float):
+        self._y = y
+
+    def generate_point(self, channel: int = 1, high_energy: bool = False) -> float:
+        """Make a point between 0 and 1 based on x and y."""
+        offset = 100 if high_energy else 10
+        return generate_interesting_pattern(self._x, self._y, channel, offset)
+
+    def open_file(self, path: Path, width: int, height: int):
+        self._file = PatternFile(path, width, height)
+
+    def _get_file(self) -> PatternFile:
+        if not self._file:
+            raise RuntimeError("open_file not run")
+        return self._file
+
+    async def write_images_to_file(
+        self, exposure: float, period: float, number_of_frames: int
+    ):
+        file = self._get_file()
+        start = time.monotonic()
+        for i in range(1, number_of_frames + 1):
+            deadline = start + i * period
+            timeout = deadline - time.monotonic()
+            await self.sleep(timeout)
+            intensity = self.generate_point() * exposure
+            file.write_image_to_file(intensity)
+
+    async def wait_for_next_index(self, timeout: float):
+        await asyncio.wait_for(self._get_file().e.wait(), timeout)
+
+    def get_last_index(self) -> int:
+        return self._get_file().image_counter
+
+    def close_file(self):
+        if self._file:
+            self._file.close()
+            self._file = None

ophyd_async/sim/_point_detector.py

@@ -0,0 +1,86 @@
+import asyncio
+import time
+
+import numpy as np
+
+from ophyd_async.core import (
+    AsyncStatus,
+    DeviceVector,
+    SignalR,
+    StandardReadable,
+    StrictEnum,
+    gather_dict,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+
+from ._pattern_generator import PatternGenerator
+
+
+class EnergyMode(StrictEnum):
+    """Energy mode for `SimPointDetector`."""
+
+    LOW = "Low Energy"
+    """Low energy mode"""
+
+    HIGH = "High Energy"
+    """High energy mode"""
+
+
+class SimPointDetectorChannel(StandardReadable):
+    def __init__(self, value_signal: SignalR[int], name=""):
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
+            self.value = value_signal
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
+            self.mode = soft_signal_rw(EnergyMode)
+        super().__init__(name)
+
+
+class SimPointDetector(StandardReadable):
+    """Simalutes a point detector with multiple channels."""
+
+    def __init__(
+        self, generator: PatternGenerator, num_channels: int = 3, name: str = ""
+    ) -> None:
+        self._generator = generator
+        self.acquire_time = soft_signal_rw(float, 0.1)
+        self.acquiring, self._set_acquiring = soft_signal_r_and_setter(bool)
+        self._value_signals = dict(
+            soft_signal_r_and_setter(int) for _ in range(num_channels)
+        )
+        with self.add_children_as_readables():
+            self.channel = DeviceVector(
+                {
+                    i + 1: SimPointDetectorChannel(value_signal)
+                    for i, value_signal in enumerate(self._value_signals)
+                }
+            )
+        super().__init__(name=name)
+
+    async def _update_values(self, acquire_time: float):
+        # Get the modes
+        modes = await gather_dict(
+            {channel: channel.mode.get_value() for channel in self.channel.values()}
+        )
+        start = time.monotonic()
+        # Make an array of relative update times at 10Hz intervals
+        update_times = np.arange(0.1, acquire_time, 0.1)
+        # With the end position appended
+        update_times = np.concatenate((update_times, [acquire_time]))
+        for update_time in update_times:
+            # Calculate how long to wait to get there
+            relative_time = time.monotonic() - start
+            await asyncio.sleep(update_time - relative_time)
+            # Update the channel value
+            for i, channel in self.channel.items():
+                high_energy = modes[channel] == EnergyMode.HIGH
+                point = self._generator.generate_point(i, high_energy)
+                setter = self._value_signals[channel.value]
+                setter(int(point * 10000 * update_time))
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        for setter in self._value_signals.values():
+            setter(0)
+        await self._update_values(await self.acquire_time.get_value())

ophyd_async/sim/_stage.py

@@ -0,0 +1,19 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.sim._pattern_generator import PatternGenerator
+
+from ._motor import SimMotor
+
+
+class SimStage(StandardReadable):
+    """A simulated sample stage with X and Y movables."""
+
+    def __init__(self, pattern_generator: PatternGenerator, name="") -> None:
+        # Define some child Devices
+        with self.add_children_as_readables():
+            self.x = SimMotor(instant=False)
+            self.y = SimMotor(instant=False)
+        # Tell the pattern generator about the motor positions
+        self.x.user_readback.subscribe_value(pattern_generator.set_x)
+        self.y.user_readback.subscribe_value(pattern_generator.set_y)
+        # Set name of device and child devices
+        super().__init__(name=name)

ophyd_async/tango/__init__.py

@@ -0,0 +1 @@
+"""Tango support for Signals, and Devices that use them."""

ophyd_async/tango/core/__init__.py

@@ -1,4 +1,4 @@
-from ._base_device import TangoDevice, TangoPolling
+from ._base_device import TangoDevice, TangoDeviceConnector, TangoPolling
 from ._signal import (
     infer_python_type,
     infer_signal_type,
@@ -19,10 +19,12 @@ from ._tango_transport import (
     get_tango_trl,
     get_trl_descriptor,
 )
+from ._utils import DevStateEnum, get_device_trl_and_attr, get_full_attr_trl
 
 __all__ = [
     "AttributeProxy",
     "CommandProxy",
+    "DevStateEnum",
     "ensure_proper_executor",
     "TangoSignalBackend",
     "get_python_type",
@@ -39,4 +41,7 @@ __all__ = [
     "TangoDevice",
     "TangoReadable",
     "TangoPolling",
+    "TangoDeviceConnector",
+    "get_device_trl_and_attr",
+    "get_full_attr_trl",
 ]

ophyd_async/tango/core/_base_device.py

@@ -4,27 +4,23 @@ 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 import DeviceProxy
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
 from ._signal import TangoSignalBackend, infer_python_type, infer_signal_type
+from ._utils import get_full_attr_trl
 
 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.
+    """General class for TangoDevices.
+
+    Extends Device to provide attributes for Tango devices.
+
+    :param trl: Tango resource locator, typically of the device server.
+        An asynchronous DeviceProxy object will be created using the
+        trl and awaited when the device is connected.
     """
 
     trl: str = ""
@@ -32,13 +28,15 @@ class TangoDevice(Device):
 
     def __init__(
         self,
-        trl: str | None = None,
-        device_proxy: DeviceProxy | None = None,
+        trl: str | None,
         support_events: bool = False,
         name: str = "",
+        auto_fill_signals: bool = True,
     ) -> None:
         connector = TangoDeviceConnector(
-            trl=trl, device_proxy=device_proxy, support_events=support_events
+            trl=trl,
+            support_events=support_events,
+            auto_fill_signals=auto_fill_signals,
         )
         super().__init__(name=name, connector=connector)
 
@@ -74,12 +72,12 @@ class TangoDeviceConnector(DeviceConnector):
     def __init__(
         self,
         trl: str | None,
-        device_proxy: DeviceProxy | None,
         support_events: bool,
+        auto_fill_signals: bool = True,
     ) -> None:
         self.trl = trl
-        self.proxy = device_proxy
         self._support_events = support_events
+        self._auto_fill_signals = auto_fill_signals
 
     def create_children_from_annotations(self, device: Device):
         if not hasattr(self, "filler"):
@@ -87,7 +85,7 @@ class TangoDeviceConnector(DeviceConnector):
                 device=device,
                 signal_backend_factory=TangoSignalBackend,
                 device_connector_factory=lambda: TangoDeviceConnector(
-                    None, None, self._support_events
+                    None, self._support_events
                 ),
             )
             list(self.filler.create_devices_from_annotations(filled=False))
@@ -105,28 +103,38 @@ class TangoDeviceConnector(DeviceConnector):
         return await super().connect_mock(device, mock)
 
     async def connect_real(self, device: Device, timeout: float, force_reconnect: bool):
-        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")
-
+        if not self.trl:
+            raise RuntimeError(f"Could not created Device Proxy for TRL {self.trl}")
+        self.proxy = await AsyncDeviceProxy(self.trl)
         children = sorted(
             set()
             .union(self.proxy.get_attribute_list())
             .union(self.proxy.get_command_list())
         )
+
+        children = [
+            child for child in children if child not in self.filler.ignored_signals
+        ]
+
+        not_filled = {unfilled for unfilled, _ in device.children()}
+
+        # If auto_fill_signals is True, fill all children inferred from the device
+        # else fill only the children that are annotated
         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 self._auto_fill_signals or name in not_filled:
+                # TODO: strip attribute name
+                full_trl = get_full_attr_trl(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)
+                    # don't overlaod datatype if provided by annotation
+                    if backend.datatype is None:
+                        backend.datatype = await infer_python_type(full_trl, self.proxy)
+                    backend.set_trl(full_trl)
+
         # 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_real(device, timeout, force_reconnect)

ophyd_async/tango/core/_converters.py

@@ -0,0 +1,81 @@
+from typing import Any, Generic
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ophyd_async.core import (
+    SignalDatatypeT,
+)
+from tango import (
+    DevState,
+)
+
+from ._utils import DevStateEnum
+
+
+class TangoConverter(Generic[SignalDatatypeT]):
+    def write_value(self, value: Any) -> Any:
+        return value
+
+    def value(self, value: Any) -> Any:
+        return value
+
+
+class TangoEnumConverter(TangoConverter):
+    def __init__(self, labels: list[str]):
+        self._labels = labels
+
+    def write_value(self, value: str):
+        if not isinstance(value, str):
+            raise TypeError("TangoEnumConverter expects str value")
+        return self._labels.index(value)
+
+    def value(self, value: int):
+        return self._labels[value]
+
+
+class TangoEnumArrayConverter(TangoConverter):
+    def __init__(self, labels: list[str]):
+        self._labels = labels
+
+    def write_value(self, value: NDArray[np.str_]) -> NDArray[np.integer]:
+        vfunc = np.vectorize(self._labels.index)
+        new_array = vfunc(value)
+        return new_array
+
+    def value(self, value: NDArray[np.integer]) -> NDArray[np.str_]:
+        vfunc = np.vectorize(self._labels.__getitem__)
+        new_array = vfunc(value)
+        return new_array
+
+
+class TangoDevStateConverter(TangoConverter):
+    _labels = [e.value for e in DevStateEnum]
+
+    def write_value(self, value: str) -> DevState:
+        idx = self._labels.index(value)
+        return DevState(idx)
+
+    def value(self, value: DevState) -> str:
+        idx = int(value)
+        return self._labels[idx]
+
+
+class TangoDevStateArrayConverter(TangoConverter):
+    _labels = [e.value for e in DevStateEnum]
+
+    def _write_convert(self, value):
+        return DevState(self._labels.index(value))
+
+    def _convert(self, value):
+        return self._labels[int(value)]
+
+    def write_value(self, value: NDArray[np.str_]) -> NDArray[DevState]:
+        vfunc = np.vectorize(self._write_convert, otypes=[DevState])
+        new_array = vfunc(value)
+        return new_array
+
+    def value(self, value: NDArray[DevState]) -> NDArray[np.str_]:
+        vfunc = np.vectorize(self._convert)
+        new_array = vfunc(value)
+        return new_array

ophyd_async/tango/core/_signal.py

@@ -1,4 +1,4 @@
-"""Tango Signals over Pytango"""
+"""Tango Signals over Pytango."""
 
 from __future__ import annotations
 
@@ -22,11 +22,11 @@ from tango import (
     CmdArgType,
     DeviceProxy,
     DevState,
-    NonSupportedFeature,  # type: ignore
 )
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
 from ._tango_transport import TangoSignalBackend, get_python_type
+from ._utils import get_device_trl_and_attr
 
 logger = logging.getLogger("ophyd_async")
 
@@ -35,20 +35,18 @@ def make_backend(
     datatype: type[SignalDatatypeT] | None,
     read_trl: str = "",
     write_trl: str = "",
-    device_proxy: DeviceProxy | None = None,
 ) -> TangoSignalBackend:
-    return TangoSignalBackend(datatype, read_trl, write_trl, device_proxy)
+    return TangoSignalBackend(datatype, read_trl, write_trl)
 
 
 def tango_signal_rw(
     datatype: type[SignalDatatypeT],
     read_trl: str,
     write_trl: str = "",
-    device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
 ) -> SignalRW[SignalDatatypeT]:
-    """Create a `SignalRW` backed by 1 or 2 Tango Attribute/Command
+    """Create a `SignalRW` backed by 1 or 2 Tango Attribute/Command.
 
     Parameters
     ----------
@@ -58,25 +56,23 @@ def tango_signal_rw(
         The Attribute/Command to read and monitor
     write_trl:
         If given, use this Attribute/Command to write to, otherwise use read_trl
-    device_proxy:
-        If given, this DeviceProxy will be used
     timeout:
         The timeout for the read and write operations
     name:
         The name of the Signal
+
     """
-    backend = make_backend(datatype, read_trl, write_trl or read_trl, device_proxy)
+    backend = make_backend(datatype, read_trl, write_trl or read_trl)
     return SignalRW(backend, timeout=timeout, name=name)
 
 
 def tango_signal_r(
     datatype: type[SignalDatatypeT],
     read_trl: str,
-    device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
 ) -> SignalR[SignalDatatypeT]:
-    """Create a `SignalR` backed by 1 Tango Attribute/Command
+    """Create a `SignalR` backed by 1 Tango Attribute/Command.
 
     Parameters
     ----------
@@ -84,25 +80,23 @@ def tango_signal_r(
         Check that the Attribute/Command is of this type
     read_trl:
         The Attribute/Command to read and monitor
-    device_proxy:
-        If given, this DeviceProxy will be used
     timeout:
         The timeout for the read operation
     name:
         The name of the Signal
+
     """
-    backend = make_backend(datatype, read_trl, read_trl, device_proxy)
+    backend = make_backend(datatype, read_trl, read_trl)
     return SignalR(backend, timeout=timeout, name=name)
 
 
 def tango_signal_w(
     datatype: type[SignalDatatypeT],
     write_trl: str,
-    device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
 ) -> SignalW[SignalDatatypeT]:
-    """Create a `SignalW` backed by 1 Tango Attribute/Command
+    """Create a `SignalW` backed by 1 Tango Attribute/Command.
 
     Parameters
     ----------
@@ -110,45 +104,43 @@ def tango_signal_w(
         Check that the Attribute/Command is of this type
     write_trl:
         The Attribute/Command to write to
-    device_proxy:
-        If given, this DeviceProxy will be used
     timeout:
         The timeout for the write operation
     name:
         The name of the Signal
+
     """
-    backend = make_backend(datatype, write_trl, write_trl, device_proxy)
+    backend = make_backend(datatype, write_trl, write_trl)
     return SignalW(backend, timeout=timeout, name=name)
 
 
 def tango_signal_x(
     write_trl: str,
-    device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
 ) -> SignalX:
-    """Create a `SignalX` backed by 1 Tango Attribute/Command
+    """Create a `SignalX` backed by 1 Tango Attribute/Command.
 
     Parameters
     ----------
     write_trl:
         The Attribute/Command to write its initial value to on execute
-    device_proxy:
-        If given, this DeviceProxy will be used
     timeout:
         The timeout for the command operation
     name:
         The name of the Signal
+
     """
-    backend = make_backend(None, write_trl, write_trl, device_proxy)
+    backend = make_backend(None, write_trl, write_trl)
     return SignalX(backend, timeout=timeout, name=name)
 
 
 async def infer_python_type(
     trl: str = "", proxy: DeviceProxy | None = None
 ) -> object | npt.NDArray | type[DevState] | IntEnum:
+    """Infers the python type from the TRL."""
     # TODO: work out if this is still needed
-    device_trl, tr_name = trl.rsplit("/", 1)
+    device_trl, tr_name = get_device_trl_and_attr(trl)
     if proxy is None:
         dev_proxy = await AsyncDeviceProxy(device_trl)
     else:
@@ -177,18 +169,12 @@ async def infer_python_type(
 async def infer_signal_type(
     trl, proxy: DeviceProxy | None = None
 ) -> type[Signal] | None:
-    device_trl, tr_name = trl.rsplit("/", 1)
+    device_trl, tr_name = get_device_trl_and_attr(trl)
     if proxy is None:
         dev_proxy = await AsyncDeviceProxy(device_trl)
     else:
         dev_proxy = proxy
 
-    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():
             raise RuntimeError(f"Cannot find {tr_name} in {device_trl}")

ophyd_async/tango/core/_tango_readable.py

@@ -1,32 +1,15 @@
 from __future__ import annotations
 
 from ophyd_async.core import StandardReadable
-from tango import DeviceProxy
 
 from ._base_device import TangoDevice
 
 
 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 = "",
+        auto_fill_signals: bool = True,
     ) -> None:
-        TangoDevice.__init__(self, trl, device_proxy=device_proxy, name=name)
+        TangoDevice.__init__(self, trl, name=name, auto_fill_signals=auto_fill_signals)