ophyd-async 0.3a1__py3-none-any.whl → 0.3a2__py3-none-any.whl

ophyd_async/epics/areadetector/pilatus.py

@@ -0,0 +1,50 @@
+from typing import Optional, Sequence
+
+from bluesky.protocols import Hints
+
+from ophyd_async.core import DirectoryProvider
+from ophyd_async.core.detector import StandardDetector
+from ophyd_async.core.signal import SignalR
+from ophyd_async.epics.areadetector.controllers.pilatus_controller import (
+    PilatusController,
+)
+from ophyd_async.epics.areadetector.drivers.ad_base import ADBaseShapeProvider
+from ophyd_async.epics.areadetector.drivers.pilatus_driver import PilatusDriver
+from ophyd_async.epics.areadetector.writers.hdf_writer import HDFWriter
+from ophyd_async.epics.areadetector.writers.nd_file_hdf import NDFileHDF
+
+
+class PilatusDetector(StandardDetector):
+    """A Pilatus StandardDetector writing HDF files"""
+
+    _controller: PilatusController
+    _writer: HDFWriter
+
+    def __init__(
+        self,
+        name: str,
+        directory_provider: DirectoryProvider,
+        driver: PilatusDriver,
+        hdf: NDFileHDF,
+        config_sigs: Optional[Sequence[SignalR]] = None,
+        **scalar_sigs: str,
+    ):
+        self.drv = driver
+        self.hdf = hdf
+
+        super().__init__(
+            PilatusController(self.drv),
+            HDFWriter(
+                self.hdf,
+                directory_provider,
+                lambda: self.name,
+                ADBaseShapeProvider(self.drv),
+                **scalar_sigs,
+            ),
+            config_sigs=config_sigs or (self.drv.acquire_time,),
+            name=name,
+        )
+
+    @property
+    def hints(self) -> Hints:
+        return self._writer.hints

ophyd_async/epics/areadetector/writers/_hdffile.py

@@ -44,10 +44,10 @@ class _HDFFile:
     def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
         # Indices are relative to resource
         if indices_written > self._last_emitted:
-            indices = dict(
-                start=self._last_emitted,
-                stop=indices_written,
-            )
+            indices = {
+                "start": self._last_emitted,
+                "stop": indices_written,
+            }
             self._last_emitted = indices_written
             for bundle in self._bundles:
                 yield bundle.compose_stream_datum(indices)

ophyd_async/epics/areadetector/writers/hdf_writer.py

@@ -109,12 +109,17 @@ class HDFWriter(DetectorWriter):
         await self.hdf.flush_now.set(True)
         if indices_written:
             if not self._file:
+                path = Path(await self.hdf.full_file_name.get_value())
                 self._file = _HDFFile(
                     self._directory_provider(),
                     # See https://github.com/bluesky/ophyd-async/issues/122
-                    Path(await self.hdf.full_file_name.get_value()),
+                    path,
                     self._datasets,
                 )
+                # stream resource says "here is a dataset",
+                # stream datum says "here are N frames in that stream resource",
+                # you get one stream resource and many stream datums per scan
+
                 for doc in self._file.stream_resources():
                     yield "stream_resource", doc
             for doc in self._file.stream_data(indices_written):

ophyd_async/epics/demo/__init__.py

@@ -14,7 +14,13 @@ from typing import Callable, List, Optional
 import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, Device, StandardReadable, observe_value
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    DeviceVector,
+    StandardReadable,
+    observe_value,
+)
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -43,6 +49,19 @@ class Sensor(StandardReadable):
         super().__init__(name=name)
 
 
+class SensorGroup(StandardReadable):
+    def __init__(self, prefix: str, name: str = "", sensor_count: int = 3) -> None:
+        self.sensors = DeviceVector(
+            {i: Sensor(f"{prefix}{i}:") for i in range(1, sensor_count + 1)}
+        )
+
+        # Makes read() produce the values of all sensors
+        self.set_readable_signals(
+            read=[sensor.value for sensor in self.sensors.values()],
+        )
+        super().__init__(name)
+
+
 class Mover(StandardReadable, Movable, Stoppable):
     """A demo movable that moves based on velocity"""
 
@@ -135,11 +154,22 @@ def start_ioc_subprocess() -> str:
     pv_prefix = "".join(random.choice(string.ascii_uppercase) for _ in range(12)) + ":"
     here = Path(__file__).absolute().parent
     args = [sys.executable, "-m", "epicscorelibs.ioc"]
+
+    # Create standalone sensor
     args += ["-m", f"P={pv_prefix}"]
     args += ["-d", str(here / "sensor.db")]
-    for suff in "XY":
-        args += ["-m", f"P={pv_prefix}{suff}:"]
+
+    # Create sensor group
+    for suffix in ["1", "2", "3"]:
+        args += ["-m", f"P={pv_prefix}{suffix}:"]
+        args += ["-d", str(here / "sensor.db")]
+
+    # Create X and Y motors
+    for suffix in ["X", "Y"]:
+        args += ["-m", f"P={pv_prefix}{suffix}:"]
         args += ["-d", str(here / "mover.db")]
+
+    # Start IOC
     process = subprocess.Popen(
         args,
         stdin=subprocess.PIPE,

ophyd_async/epics/motion/motor.py

@@ -14,33 +14,39 @@ class Motor(StandardReadable, Movable, Stoppable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        self.setpoint = epics_signal_rw(float, prefix + ".VAL")
-        self.readback = epics_signal_r(float, prefix + ".RBV")
+        self.user_setpoint = epics_signal_rw(float, prefix + ".VAL")
+        self.user_readback = epics_signal_r(float, prefix + ".RBV")
         self.velocity = epics_signal_rw(float, prefix + ".VELO")
-        self.units = epics_signal_r(str, prefix + ".EGU")
+        self.max_velocity = epics_signal_r(float, prefix + ".VMAX")
+        self.acceleration_time = epics_signal_rw(float, prefix + ".ACCL")
+        self.motor_egu = epics_signal_r(str, prefix + ".EGU")
         self.precision = epics_signal_r(int, prefix + ".PREC")
-        # Signals that collide with standard methods should have a trailing underscore
-        self.stop_ = epics_signal_x(prefix + ".STOP")
+        self.deadband = epics_signal_r(float, prefix + ".RDBD")
+        self.motor_done_move = epics_signal_r(float, prefix + ".DMOV")
+        self.low_limit_travel = epics_signal_rw(int, prefix + ".LLM")
+        self.high_limit_travel = epics_signal_rw(int, prefix + ".HLM")
+
+        self.motor_stop = epics_signal_x(prefix + ".STOP")
         # Whether set() should complete successfully or not
         self._set_success = True
         # Set name and signals for read() and read_configuration()
         self.set_readable_signals(
-            read=[self.readback],
-            config=[self.velocity, self.units],
+            read=[self.user_readback],
+            config=[self.velocity, self.motor_egu],
         )
         super().__init__(name=name)
 
     def set_name(self, name: str):
         super().set_name(name)
         # Readback should be named the same as its parent in read()
-        self.readback.set_name(name)
+        self.user_readback.set_name(name)
 
     async def _move(self, new_position: float, watchers: List[Callable] = []):
         self._set_success = True
         start = time.monotonic()
         old_position, units, precision = await asyncio.gather(
-            self.setpoint.get_value(),
-            self.units.get_value(),
+            self.user_setpoint.get_value(),
+            self.motor_egu.get_value(),
             self.precision.get_value(),
         )
 
@@ -56,11 +62,11 @@ class Motor(StandardReadable, Movable, Stoppable):
                     time_elapsed=time.monotonic() - start,
                 )
 
-        self.readback.subscribe_value(update_watchers)
+        self.user_readback.subscribe_value(update_watchers)
         try:
-            await self.setpoint.set(new_position)
+            await self.user_setpoint.set(new_position)
         finally:
-            self.readback.clear_sub(update_watchers)
+            self.user_readback.clear_sub(update_watchers)
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
 
@@ -81,5 +87,5 @@ class Motor(StandardReadable, Movable, Stoppable):
         self._set_success = success
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
-        status = self.stop_.trigger(wait=False)
+        status = self.motor_stop.trigger(wait=False)
         await status

ophyd_async/epics/pvi/__init__.py

@@ -0,0 +1,3 @@
+from .pvi import PVIEntry, create_children_from_annotations, fill_pvi_entries
+
+__all__ = ["PVIEntry", "fill_pvi_entries", "create_children_from_annotations"]

ophyd_async/epics/pvi/pvi.py

@@ -0,0 +1,318 @@
+import re
+from dataclasses import dataclass
+from inspect import isclass
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    FrozenSet,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from ophyd_async.core import Device, DeviceVector, SimSignalBackend
+from ophyd_async.core.signal import Signal
+from ophyd_async.core.utils import DEFAULT_TIMEOUT
+from ophyd_async.epics._backend._p4p import PvaSignalBackend
+from ophyd_async.epics.signal.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_w,
+    epics_signal_x,
+)
+
+T = TypeVar("T")
+Access = FrozenSet[
+    Union[Literal["r"], Literal["w"], Literal["rw"], Literal["x"], Literal["d"]]
+]
+
+
+def _strip_number_from_string(string: str) -> Tuple[str, Optional[int]]:
+    match = re.match(r"(.*?)(\d*)$", string)
+    assert match
+
+    name = match.group(1)
+    number = match.group(2) or None
+    if number:
+        number = int(number)
+    return name, number
+
+
+def _split_subscript(tp: T) -> Union[Tuple[Any, Tuple[Any]], Tuple[T, None]]:
+    """Split a subscripted type into the its origin and args.
+
+    If `tp` is not a subscripted type, then just return the type and None as args.
+
+    """
+    if get_origin(tp) is not None:
+        return get_origin(tp), get_args(tp)
+
+    return tp, None
+
+
+def _strip_union(field: Union[Union[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: Union[Type[Device]]) -> Tuple[bool, Type[Device]]:
+    if get_origin(field) is DeviceVector:
+        return True, get_args(field)[0]
+    return False, field
+
+
+@dataclass
+class PVIEntry:
+    """
+    A dataclass to represent a single entry in the PVI table.
+    This could either be a signal or a sub-table.
+    """
+
+    sub_entries: Dict[str, Union[Dict[int, "PVIEntry"], "PVIEntry"]]
+    pvi_pv: Optional[str] = None
+    device: Optional[Device] = None
+    common_device_type: Optional[Type[Device]] = None
+
+
+def _verify_common_blocks(entry: PVIEntry, common_device: Type[Device]):
+    if not entry.sub_entries:
+        return
+    common_sub_devices = get_type_hints(common_device)
+    for sub_name, sub_device in common_sub_devices.items():
+        if sub_name in ("_name", "parent"):
+            continue
+        assert entry.sub_entries
+        device_t, is_optional = _strip_union(sub_device)
+        if sub_name not in entry.sub_entries and not is_optional:
+            raise RuntimeError(
+                f"sub device `{sub_name}:{type(sub_device)}` " "was not provided by pvi"
+            )
+        if isinstance(entry.sub_entries[sub_name], dict):
+            for sub_sub_entry in entry.sub_entries[sub_name].values():  # type: ignore
+                _verify_common_blocks(sub_sub_entry, sub_device)  # type: ignore
+        else:
+            _verify_common_blocks(
+                entry.sub_entries[sub_name],
+                sub_device,  # type: ignore
+            )
+
+
+_pvi_mapping: Dict[FrozenSet[str], Callable[..., Signal]] = {
+    frozenset({"r", "w"}): lambda dtype, read_pv, write_pv: epics_signal_rw(
+        dtype, "pva://" + read_pv, "pva://" + write_pv
+    ),
+    frozenset({"rw"}): lambda dtype, read_write_pv: epics_signal_rw(
+        dtype, "pva://" + read_write_pv, write_pv="pva://" + read_write_pv
+    ),
+    frozenset({"r"}): lambda dtype, read_pv: epics_signal_r(dtype, "pva://" + read_pv),
+    frozenset({"w"}): lambda dtype, write_pv: epics_signal_w(
+        dtype, "pva://" + write_pv
+    ),
+    frozenset({"x"}): lambda _, write_pv: epics_signal_x("pva://" + write_pv),
+}
+
+
+def _parse_type(
+    is_pvi_table: bool,
+    number_suffix: Optional[int],
+    common_device_type: Optional[Type[Device]],
+):
+    if common_device_type:
+        # pre-defined type
+        device_cls, _ = _strip_union(common_device_type)
+        is_device_vector, device_cls = _strip_device_vector(device_cls)
+        device_cls, device_args = _split_subscript(device_cls)
+        assert issubclass(device_cls, Device)
+
+        is_signal = issubclass(device_cls, Signal)
+        signal_dtype = device_args[0] if device_args is not None else None
+
+    elif is_pvi_table:
+        # is a block, we can make it a DeviceVector if it ends in a number
+        is_device_vector = number_suffix is not None
+        is_signal = False
+        signal_dtype = None
+        device_cls = Device
+    else:
+        # is a signal, signals aren't stored in DeviceVectors unless
+        # they're defined as such in the common_device_type
+        is_device_vector = False
+        is_signal = True
+        signal_dtype = None
+        device_cls = Signal
+
+    return is_device_vector, is_signal, signal_dtype, device_cls
+
+
+def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
+    device_t = stripped_type or type(device)
+    sub_devices = (
+        (field, field_type)
+        for field, field_type in get_type_hints(device_t).items()
+        if field not in ("_name", "parent")
+    )
+
+    for device_name, device_cls in sub_devices:
+        device_cls, _ = _strip_union(device_cls)
+        is_device_vector, device_cls = _strip_device_vector(device_cls)
+        device_cls, device_args = _split_subscript(device_cls)
+        assert issubclass(device_cls, Device)
+
+        is_signal = issubclass(device_cls, Signal)
+        signal_dtype = device_args[0] if device_args is not None else None
+
+        if is_device_vector:
+            if is_signal:
+                sub_device_1 = device_cls(SimSignalBackend(signal_dtype))
+                sub_device_2 = device_cls(SimSignalBackend(signal_dtype))
+                sub_device = DeviceVector({1: sub_device_1, 2: sub_device_2})
+            else:
+                sub_device = DeviceVector({1: device_cls(), 2: device_cls()})
+
+                for sub_device_in_vector in sub_device.values():
+                    _sim_common_blocks(sub_device_in_vector, stripped_type=device_cls)
+
+            for value in sub_device.values():
+                value.parent = sub_device
+        else:
+            if is_signal:
+                sub_device = device_cls(SimSignalBackend(signal_dtype))
+            else:
+                sub_device = getattr(device, device_name, device_cls())
+                _sim_common_blocks(sub_device, stripped_type=device_cls)
+
+        setattr(device, device_name, sub_device)
+        sub_device.parent = device
+
+
+async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
+    if not entry.pvi_pv or not entry.pvi_pv.endswith(":PVI"):
+        raise RuntimeError("Top level entry must be a pvi table")
+
+    pvi_table_signal_backend: PvaSignalBackend = PvaSignalBackend(
+        None, entry.pvi_pv, entry.pvi_pv
+    )
+    await pvi_table_signal_backend.connect(
+        timeout=timeout
+    )  # create table signal backend
+
+    pva_table = (await pvi_table_signal_backend.get_value())["pvi"]
+    common_device_type_hints = (
+        get_type_hints(entry.common_device_type) if entry.common_device_type else {}
+    )
+
+    for sub_name, pva_entries in pva_table.items():
+        pvs = list(pva_entries.values())
+        is_pvi_table = len(pvs) == 1 and pvs[0].endswith(":PVI")
+        sub_name_split, sub_number_split = _strip_number_from_string(sub_name)
+        is_device_vector, is_signal, signal_dtype, device_type = _parse_type(
+            is_pvi_table,
+            sub_number_split,
+            common_device_type_hints.get(sub_name_split),
+        )
+        if is_signal:
+            device = _pvi_mapping[frozenset(pva_entries.keys())](signal_dtype, *pvs)
+        else:
+            device = getattr(entry.device, sub_name, device_type())
+
+        sub_entry = PVIEntry(
+            device=device, common_device_type=device_type, sub_entries={}
+        )
+
+        if is_device_vector:
+            # If device vector then we store sub_name -> {sub_number -> sub_entry}
+            # and aggregate into `DeviceVector` in `_set_device_attributes`
+            sub_number_split = 1 if sub_number_split is None else sub_number_split
+            if sub_name_split not in entry.sub_entries:
+                entry.sub_entries[sub_name_split] = {}
+            entry.sub_entries[sub_name_split][sub_number_split] = sub_entry  # type: ignore
+        else:
+            entry.sub_entries[sub_name] = sub_entry
+
+        if is_pvi_table:
+            sub_entry.pvi_pv = pvs[0]
+            await _get_pvi_entries(sub_entry)
+
+    if entry.common_device_type:
+        _verify_common_blocks(entry, entry.common_device_type)
+
+
+def _set_device_attributes(entry: PVIEntry):
+    for sub_name, sub_entry in entry.sub_entries.items():
+        if isinstance(sub_entry, dict):
+            sub_device = DeviceVector()  # type: ignore
+            for key, device_vector_sub_entry in sub_entry.items():
+                sub_device[key] = device_vector_sub_entry.device
+                if device_vector_sub_entry.pvi_pv:
+                    _set_device_attributes(device_vector_sub_entry)
+                # Set the device vector entry to have the device vector as a parent
+                device_vector_sub_entry.device.parent = sub_device  # type: ignore
+        else:
+            sub_device = sub_entry.device  # type: ignore
+            if sub_entry.pvi_pv:
+                _set_device_attributes(sub_entry)
+
+        sub_device.parent = entry.device
+        setattr(entry.device, sub_name, sub_device)
+
+
+async def fill_pvi_entries(
+    device: Device, root_pv: str, timeout=DEFAULT_TIMEOUT, sim=False
+):
+    """
+    Fills a ``device`` with signals from a the ``root_pvi:PVI`` table.
+
+    If the device names match with parent devices of ``device`` then types are used.
+    """
+    if sim:
+        # set up sim signals for the common annotations
+        _sim_common_blocks(device)
+    else:
+        # check the pvi table for devices and fill the device with them
+        root_entry = PVIEntry(
+            pvi_pv=root_pv,
+            device=device,
+            common_device_type=type(device),
+            sub_entries={},
+        )
+        await _get_pvi_entries(root_entry, timeout=timeout)
+        _set_device_attributes(root_entry)
+
+    # We call set name now the parent field has been set in all of the
+    # introspect-initialized devices. This will recursively set the names.
+    device.set_name(device.name)
+
+
+def create_children_from_annotations(
+    device: Device, included_optional_fields: Tuple[str, ...] = ()
+):
+    """For intializing 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
+            or ((origin := get_origin(device_type)) and issubclass(origin, Signal))
+            or (isclass(device_type) and issubclass(device_type, Signal))
+        ):
+            continue
+
+        sub_device = device_type()
+        setattr(device, name, sub_device)
+        create_children_from_annotations(sub_device)

ophyd_async/epics/signal/signal.py

@@ -41,7 +41,7 @@ def _make_backend(
 
 
 def epics_signal_rw(
-    datatype: Type[T], read_pv: str, write_pv: Optional[str] = None
+    datatype: Type[T], read_pv: str, write_pv: Optional[str] = None, name: str = ""
 ) -> SignalRW[T]:
     """Create a `SignalRW` backed by 1 or 2 EPICS PVs
 
@@ -55,24 +55,41 @@ def epics_signal_rw(
         If given, use this PV to write to, otherwise use read_pv
     """
     backend = _make_backend(datatype, read_pv, write_pv or read_pv)
-    return SignalRW(backend)
+    return SignalRW(backend, name=name)
 
 
-def epics_signal_r(datatype: Type[T], read_pv: str) -> SignalR[T]:
-    """Create a `SignalR` backed by 1 EPICS PV
+def epics_signal_rw_rbv(
+    datatype: Type[T], write_pv: str, read_suffix: str = "_RBV", name: str = ""
+) -> SignalRW[T]:
+    """Create a `SignalRW` backed by 1 or 2 EPICS PVs, with a suffix on the readback pv
 
     Parameters
     ----------
     datatype:
         Check that the PV is of this type
+    write_pv:
+        The PV to write to
+    read_suffix:
+        Append this suffix to the write pv to create the readback pv
+    """
+    return epics_signal_rw(datatype, f"{write_pv}{read_suffix}", write_pv, name)
+
+
+def epics_signal_r(datatype: Type[T], read_pv: str, name: str = "") -> SignalR[T]:
+    """Create a `SignalR` backed by 1 EPICS PV
+
+    Parameters
+    ---------
+    datatype
+        Check that the PV is of this type
     read_pv:
         The PV to read and monitor
     """
     backend = _make_backend(datatype, read_pv, read_pv)
-    return SignalR(backend)
+    return SignalR(backend, name=name)
 
 
-def epics_signal_w(datatype: Type[T], write_pv: str) -> SignalW[T]:
+def epics_signal_w(datatype: Type[T], write_pv: str, name: str = "") -> SignalW[T]:
     """Create a `SignalW` backed by 1 EPICS PVs
 
     Parameters
@@ -83,10 +100,10 @@ def epics_signal_w(datatype: Type[T], write_pv: str) -> SignalW[T]:
         The PV to write to
     """
     backend = _make_backend(datatype, write_pv, write_pv)
-    return SignalW(backend)
+    return SignalW(backend, name=name)
 
 
-def epics_signal_x(write_pv: str) -> SignalX:
+def epics_signal_x(write_pv: str, name: str = "") -> SignalX:
     """Create a `SignalX` backed by 1 EPICS PVs
 
     Parameters
@@ -95,4 +112,4 @@ def epics_signal_x(write_pv: str) -> SignalX:
         The PV to write its initial value to on trigger
     """
     backend: SignalBackend = _make_backend(None, write_pv, write_pv)
-    return SignalX(backend)
+    return SignalX(backend, name=name)

ophyd_async/panda/__init__.py

@@ -1,19 +1,27 @@
-from .panda import PandA, PcapBlock, PulseBlock, PVIEntry, SeqBlock, SeqTable
-from .panda_controller import PandaPcapController
-from .table import (
+from ._common_blocks import (
+    CommonPandaBlocks,
+    DataBlock,
+    PcapBlock,
+    PulseBlock,
+    SeqBlock,
+    TimeUnits,
+)
+from ._hdf_panda import HDFPanda
+from ._panda_controller import PandaPcapController
+from ._table import (
     SeqTable,
     SeqTableRow,
     SeqTrigger,
     seq_table_from_arrays,
     seq_table_from_rows,
 )
-from .utils import phase_sorter
+from ._utils import phase_sorter
 
 __all__ = [
-    "PandA",
+    "CommonPandaBlocks",
+    "HDFPanda",
     "PcapBlock",
     "PulseBlock",
-    "PVIEntry",
     "seq_table_from_arrays",
     "seq_table_from_rows",
     "SeqBlock",
@@ -22,4 +30,7 @@ __all__ = [
     "SeqTrigger",
     "phase_sorter",
     "PandaPcapController",
+    "TimeUnits",
+    "DataBlock",
+    "CommonPandABlocks",
 ]