ophyd-async 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

ophyd_async/epics/_backend/common.py

@@ -1,6 +1,8 @@
 import inspect
 from enum import Enum
-from typing import Dict, Optional, Tuple, Type, TypedDict
+from typing import Dict, Optional, Tuple, Type
+
+from typing_extensions import TypedDict
 
 from ophyd_async.core.signal_backend import RuntimeSubsetEnum
 

ophyd_async/epics/areadetector/aravis.py

@@ -2,7 +2,7 @@ from typing import get_args
 
 from bluesky.protocols import HasHints, Hints
 
-from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.core import PathProvider, StandardDetector
 from ophyd_async.epics.areadetector.controllers.aravis_controller import (
     AravisController,
 )
@@ -24,7 +24,7 @@ class AravisDetector(StandardDetector, HasHints):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix="cam1:",
         hdf_suffix="HDF1:",
         name="",
@@ -37,7 +37,7 @@ class AravisDetector(StandardDetector, HasHints):
             AravisController(self.drv, gpio_number=gpio_number),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/areadetector/controllers/aravis_controller.py

@@ -62,6 +62,7 @@ class AravisController(DetectorControl):
         supported_trigger_types = (
             DetectorTrigger.constant_gate,
             DetectorTrigger.edge_trigger,
+            DetectorTrigger.internal,
         )
         if trigger not in supported_trigger_types:
             raise ValueError(

ophyd_async/epics/areadetector/drivers/ad_base.py

@@ -1,6 +1,6 @@
 import asyncio
 from enum import Enum
-from typing import FrozenSet, Sequence, Set
+from typing import FrozenSet, Set
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -131,9 +131,10 @@ class ADBaseShapeProvider(ShapeProvider):
     def __init__(self, driver: ADBase) -> None:
         self._driver = driver
 
-    async def __call__(self) -> Sequence[int]:
+    async def __call__(self) -> tuple:
         shape = await asyncio.gather(
             self._driver.array_size_y.get_value(),
             self._driver.array_size_x.get_value(),
+            self._driver.data_type.get_value(),
         )
         return shape

ophyd_async/epics/areadetector/kinetix.py

@@ -1,6 +1,6 @@
 from bluesky.protocols import HasHints, Hints
 
-from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.core import PathProvider, StandardDetector
 from ophyd_async.epics.areadetector.controllers.kinetix_controller import (
     KinetixController,
 )
@@ -21,7 +21,7 @@ class KinetixDetector(StandardDetector, HasHints):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix="cam1:",
         hdf_suffix="HDF1:",
         name="",
@@ -33,7 +33,7 @@ class KinetixDetector(StandardDetector, HasHints):
             KinetixController(self.drv),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/areadetector/pilatus.py

@@ -2,7 +2,7 @@ from enum import Enum
 
 from bluesky.protocols import Hints
 
-from ophyd_async.core import DirectoryProvider
+from ophyd_async.core import PathProvider
 from ophyd_async.core.detector import StandardDetector
 from ophyd_async.epics.areadetector.controllers.pilatus_controller import (
     PilatusController,
@@ -36,7 +36,7 @@ class PilatusDetector(StandardDetector):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         readout_time: PilatusReadoutTime = PilatusReadoutTime.pilatus3,
         drv_suffix: str = "cam1:",
         hdf_suffix: str = "HDF1:",
@@ -49,7 +49,7 @@ class PilatusDetector(StandardDetector):
             PilatusController(self.drv, readout_time=readout_time.value),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/areadetector/vimba.py

@@ -1,6 +1,6 @@
 from bluesky.protocols import HasHints, Hints
 
-from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.core import PathProvider, StandardDetector
 from ophyd_async.epics.areadetector.controllers.vimba_controller import VimbaController
 from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
 from ophyd_async.epics.areadetector.drivers.vimba_driver import VimbaDriver
@@ -18,7 +18,7 @@ class VimbaDetector(StandardDetector, HasHints):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix="cam1:",
         hdf_suffix="HDF1:",
         name="",
@@ -30,7 +30,7 @@ class VimbaDetector(StandardDetector, HasHints):
             VimbaController(self.drv),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/areadetector/writers/__init__.py

@@ -1,5 +1,5 @@
 from .hdf_writer import HDFWriter
 from .nd_file_hdf import NDFileHDF
-from .nd_plugin import NDPluginBase, NDPluginStats
+from .nd_plugin import ADBaseDataType, NDPluginBase, NDPluginStats
 
-__all__ = ["HDFWriter", "NDFileHDF", "NDPluginBase", "NDPluginStats"]
+__all__ = ["HDFWriter", "NDFileHDF", "NDPluginBase", "NDPluginStats", "ADBaseDataType"]

ophyd_async/epics/areadetector/writers/general_hdffile.py

@@ -0,0 +1,97 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterator, List, Sequence
+from urllib.parse import urlunparse
+
+from event_model import (
+    ComposeStreamResource,
+    ComposeStreamResourceBundle,
+    StreamDatum,
+    StreamResource,
+)
+
+from ophyd_async.core import PathInfo
+
+
+@dataclass
+class _HDFDataset:
+    data_key: str
+    dataset: str
+    shape: Sequence[int] = field(default_factory=tuple)
+    dtype_numpy: str = ""
+    multiplier: int = 1
+    swmr: bool = False
+
+
+SLICE_NAME = "AD_HDF5_SWMR_SLICE"
+
+
+class _HDFFile:
+    """
+    :param directory_info: Contains information about how to construct a StreamResource
+    :param full_file_name: Absolute path to the file to be written
+    :param datasets: Datasets to write into the file
+    """
+
+    def __init__(
+        self,
+        path_info: PathInfo,
+        full_file_name: Path,
+        datasets: List[_HDFDataset],
+        hostname: str = "localhost",
+    ) -> None:
+        self._last_emitted = 0
+        self._hostname = hostname
+
+        if len(datasets) == 0:
+            self._bundles = []
+            return None
+
+        bundler_composer = ComposeStreamResource()
+
+        uri = urlunparse(
+            (
+                "file",
+                self._hostname,
+                str((path_info.root / full_file_name).absolute()),
+                "",
+                "",
+                None,
+            )
+        )
+
+        self._bundles: List[ComposeStreamResourceBundle] = [
+            bundler_composer(
+                mimetype="application/x-hdf5",
+                uri=uri,
+                data_key=ds.data_key,
+                parameters={
+                    "dataset": ds.dataset,
+                    "swmr": ds.swmr,
+                    "multiplier": ds.multiplier,
+                },
+                uid=None,
+                validate=True,
+            )
+            for ds in datasets
+        ]
+
+    def stream_resources(self) -> Iterator[StreamResource]:
+        for bundle in self._bundles:
+            yield bundle.stream_resource_doc
+
+    def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
+        # Indices are relative to resource
+        if indices_written > self._last_emitted:
+            indices = {
+                "start": self._last_emitted,
+                "stop": indices_written,
+            }
+            self._last_emitted = indices_written
+            for bundle in self._bundles:
+                yield bundle.compose_stream_datum(indices)
+        return None
+
+    def close(self) -> None:
+        for bundle in self._bundles:
+            bundle.close()

ophyd_async/epics/areadetector/writers/hdf_writer.py

@@ -8,30 +8,30 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     DetectorWriter,
-    DirectoryProvider,
     NameProvider,
+    PathProvider,
     ShapeProvider,
     set_and_wait_for_value,
     wait_for_value,
 )
 from ophyd_async.core.signal import observe_value
 
-from ._hdfdataset import _HDFDataset
-from ._hdffile import _HDFFile
+from .general_hdffile import _HDFDataset, _HDFFile
 from .nd_file_hdf import FileWriteMode, NDFileHDF
+from .nd_plugin import convert_ad_dtype_to_np
 
 
 class HDFWriter(DetectorWriter):
     def __init__(
         self,
         hdf: NDFileHDF,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         name_provider: NameProvider,
         shape_provider: ShapeProvider,
         **scalar_datasets_paths: str,
     ) -> None:
         self.hdf = hdf
-        self._directory_provider = directory_provider
+        self._path_provider = path_provider
         self._name_provider = name_provider
         self._shape_provider = shape_provider
         self._scalar_datasets_paths = scalar_datasets_paths
@@ -42,7 +42,7 @@ class HDFWriter(DetectorWriter):
 
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         self._file = None
-        info = self._directory_provider()
+        info = self._path_provider(device_name=self.hdf.name)
         file_path = str(info.root / info.resource_dir)
         await asyncio.gather(
             self.hdf.num_extra_dims.set(0),
@@ -50,8 +50,9 @@ class HDFWriter(DetectorWriter):
             self.hdf.swmr_mode.set(True),
             # See https://github.com/bluesky/ophyd-async/issues/122
             self.hdf.file_path.set(file_path),
-            self.hdf.file_name.set(f"{info.prefix}{self.hdf.name}{info.suffix}"),
+            self.hdf.file_name.set(info.filename),
             self.hdf.file_template.set("%s/%s.h5"),
+            self.hdf.create_dir_depth.set(info.create_dir_depth),
             self.hdf.file_write_mode.set(FileWriteMode.stream),
             # Never use custom xml layout file but use the one defined
             # in the source code file NDFileHDF5LayoutXML.cpp
@@ -70,9 +71,22 @@ class HDFWriter(DetectorWriter):
         detector_shape = tuple(await self._shape_provider())
         self._multiplier = multiplier
         outer_shape = (multiplier,) if multiplier > 1 else ()
+        frame_shape = detector_shape[:-1] if len(detector_shape) > 0 else []
+        dtype_numpy = (
+            convert_ad_dtype_to_np(detector_shape[-1])
+            if len(detector_shape) > 0
+            else ""
+        )
+
         # Add the main data
         self._datasets = [
-            _HDFDataset(name, "/entry/data/data", detector_shape, multiplier)
+            _HDFDataset(
+                data_key=name,
+                dataset="/entry/data/data",
+                shape=frame_shape,
+                dtype_numpy=dtype_numpy,
+                multiplier=multiplier,
+            )
         ]
         # And all the scalar datasets
         for ds_name, ds_path in self._scalar_datasets_paths.items():
@@ -81,14 +95,17 @@ class HDFWriter(DetectorWriter):
                     f"{name}-{ds_name}",
                     f"/entry/instrument/NDAttributes/{ds_path}",
                     (),
+                    "",
                     multiplier,
                 )
             )
+
         describe = {
-            ds.name: DataKey(
+            ds.data_key: DataKey(
                 source=self.hdf.full_file_name.source,
                 shape=outer_shape + tuple(ds.shape),
                 dtype="array" if ds.shape else "number",
+                dtype_numpy=ds.dtype_numpy,
                 external="STREAM:",
             )
             for ds in self._datasets
@@ -115,7 +132,7 @@ class HDFWriter(DetectorWriter):
             if not self._file:
                 path = Path(await self.hdf.full_file_name.get_value())
                 self._file = _HDFFile(
-                    self._directory_provider(),
+                    self._path_provider(),
                     # See https://github.com/bluesky/ophyd-async/issues/122
                     path,
                     self._datasets,

ophyd_async/epics/areadetector/writers/nd_file_hdf.py

@@ -37,4 +37,7 @@ class NDFileHDF(NDPluginBase):
         self.capture = epics_signal_rw_rbv(bool, prefix + "Capture")
         self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
         self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
+        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0")
+        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1")
+        self.create_dir_depth = epics_signal_rw(int, prefix + "CreateDirectory")
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/writers/nd_plugin.py

@@ -10,6 +10,35 @@ class Callback(str, Enum):
     Disable = "Disable"
 
 
+class ADBaseDataType(str, Enum):
+    Int8 = "Int8"
+    UInt8 = "UInt8"
+    Int16 = "Int16"
+    UInt16 = "UInt16"
+    Int32 = "Int32"
+    UInt32 = "UInt32"
+    Int64 = "Int64"
+    UInt64 = "UInt64"
+    Float32 = "Float32"
+    Float64 = "Float64"
+
+
+def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
+    ad_dtype_to_np_dtype = {
+        ADBaseDataType.Int8: "|i1",
+        ADBaseDataType.UInt8: "|u1",
+        ADBaseDataType.Int16: "<i2",
+        ADBaseDataType.UInt16: "<u2",
+        ADBaseDataType.Int32: "<i4",
+        ADBaseDataType.UInt32: "<u4",
+        ADBaseDataType.Int64: "<i8",
+        ADBaseDataType.UInt64: "<u8",
+        ADBaseDataType.Float32: "<f4",
+        ADBaseDataType.Float64: "<f8",
+    }
+    return ad_dtype_to_np_dtype[ad_dtype]
+
+
 class NDArrayBase(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
         self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
@@ -17,6 +46,7 @@ class NDArrayBase(Device):
         self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
         self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
         self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
+        self.data_type = epics_signal_r(ADBaseDataType, prefix + "NDDataType_RBV")
         self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
         # There is no _RBV for this one
         self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")

ophyd_async/epics/demo/demo_ad_sim_detector.py

@@ -1,6 +1,6 @@
 from typing import Sequence
 
-from ophyd_async.core import DirectoryProvider, SignalR, StandardDetector
+from ophyd_async.core import PathProvider, SignalR, StandardDetector
 
 from ..areadetector.controllers import ADSimController
 from ..areadetector.drivers import ADBase, ADBaseShapeProvider
@@ -15,7 +15,7 @@ class DemoADSimDetector(StandardDetector):
         self,
         drv: ADBase,
         hdf: NDFileHDF,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         name: str = "",
         config_sigs: Sequence[SignalR] = (),
     ):
@@ -26,7 +26,7 @@ class DemoADSimDetector(StandardDetector):
             ADSimController(self.drv),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/motion/motor.py

@@ -1,6 +1,8 @@
 import asyncio
+from typing import Optional
 
-from bluesky.protocols import Movable, Stoppable
+from bluesky.protocols import Flyable, Movable, Preparable, Stoppable
+from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
     ConfigSignal,
@@ -8,6 +10,7 @@ from ophyd_async.core import (
     StandardReadable,
     WatchableAsyncStatus,
 )
+from ophyd_async.core.async_status import AsyncStatus
 from ophyd_async.core.signal import observe_value
 from ophyd_async.core.utils import (
     DEFAULT_TIMEOUT,
@@ -19,7 +22,39 @@ from ophyd_async.core.utils import (
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
 
-class Motor(StandardReadable, Movable, Stoppable):
+class MotorLimitsException(Exception):
+    pass
+
+
+class InvalidFlyMotorException(Exception):
+    pass
+
+
+DEFAULT_MOTOR_FLY_TIMEOUT = 60
+DEFAULT_WATCHER_UPDATE_FREQUENCY = 0.2
+
+
+class FlyMotorInfo(BaseModel):
+    """Minimal set of information required to fly a motor:"""
+
+    #: Absolute position of the motor once it finishes accelerating to desired
+    #: velocity, in motor EGUs
+    start_position: float = Field(frozen=True)
+
+    #: Absolute position of the motor once it begins decelerating from desired
+    #: velocity, in EGUs
+    end_position: float = Field(frozen=True)
+
+    #: Time taken for the motor to get from start_position to end_position, excluding
+    #: run-up and run-down, in seconds.
+    time_for_move: float = Field(frozen=True, gt=0)
+
+    #: Maximum time for the complete motor move, including run up and run down.
+    #: Defaults to `time_for_move` + run up and run down times + 10s.
+    timeout: CalculatableTimeout = Field(frozen=True, default=CalculateTimeout)
+
+
+class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
     """Device that moves a motor record"""
 
     def __init__(self, prefix: str, name="") -> None:
@@ -43,6 +78,16 @@ class Motor(StandardReadable, Movable, Stoppable):
         self.motor_stop = epics_signal_x(prefix + ".STOP")
         # Whether set() should complete successfully or not
         self._set_success = True
+
+        # end_position of a fly move, with run_up_distance added on.
+        self._fly_completed_position: Optional[float] = None
+
+        # Set on kickoff(), complete when motor reaches self._fly_completed_position
+        self._fly_status: Optional[WatchableAsyncStatus] = None
+
+        # Set during prepare
+        self._fly_timeout: Optional[CalculatableTimeout] = CalculateTimeout
+
         super().__init__(name=name)
 
     def set_name(self, name: str):
@@ -50,6 +95,44 @@ class Motor(StandardReadable, Movable, Stoppable):
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
+    @AsyncStatus.wrap
+    async def prepare(self, value: FlyMotorInfo):
+        """Calculate required velocity and run-up distance, then if motor limits aren't
+        breached, move to start position minus run-up distance"""
+
+        self._fly_timeout = value.timeout
+
+        # Velocity, at which motor travels from start_position to end_position, in motor
+        # egu/s.
+        fly_velocity = await self._prepare_velocity(
+            value.start_position,
+            value.end_position,
+            value.time_for_move,
+        )
+
+        # start_position with run_up_distance added on.
+        fly_prepared_position = await self._prepare_motor_path(
+            abs(fly_velocity), value.start_position, value.end_position
+        )
+
+        await self.set(fly_prepared_position)
+
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        """Begin moving motor from prepared position to final position."""
+        assert (
+            self._fly_completed_position
+        ), "Motor must be prepared before attempting to kickoff"
+
+        self._fly_status = self.set(
+            self._fly_completed_position, timeout=self._fly_timeout
+        )
+
+    def complete(self) -> WatchableAsyncStatus:
+        """Mark as complete once motor reaches completed position."""
+        assert self._fly_status, "kickoff not called"
+        return self._fly_status
+
     @WatchableAsyncStatus.wrap
     async def set(
         self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
@@ -95,3 +178,50 @@ class Motor(StandardReadable, Movable, Stoppable):
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
         await self.motor_stop.trigger(wait=False)
+
+    async def _prepare_velocity(
+        self, start_position: float, end_position: float, time_for_move: float
+    ) -> float:
+        fly_velocity = (start_position - end_position) / time_for_move
+        max_speed, egu = await asyncio.gather(
+            self.max_velocity.get_value(), self.motor_egu.get_value()
+        )
+        if abs(fly_velocity) > max_speed:
+            raise MotorLimitsException(
+                f"Motor speed of {abs(fly_velocity)} {egu}/s was requested for a motor "
+                f" with max speed of {max_speed} {egu}/s"
+            )
+        await self.velocity.set(abs(fly_velocity))
+        return fly_velocity
+
+    async def _prepare_motor_path(
+        self, fly_velocity: float, start_position: float, end_position: float
+    ) -> float:
+        # Distance required for motor to accelerate from stationary to fly_velocity, and
+        # distance required for motor to decelerate from fly_velocity to stationary
+        run_up_distance = (await self.acceleration_time.get_value()) * fly_velocity
+
+        self._fly_completed_position = end_position + run_up_distance
+
+        # Prepared position not used after prepare, so no need to store in self
+        fly_prepared_position = start_position - run_up_distance
+
+        motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
+            self.low_limit_travel.get_value(),
+            self.high_limit_travel.get_value(),
+            self.motor_egu.get_value(),
+        )
+
+        if (
+            not motor_upper_limit >= fly_prepared_position >= motor_lower_limit
+            or not motor_upper_limit
+            >= self._fly_completed_position
+            >= motor_lower_limit
+        ):
+            raise MotorLimitsException(
+                f"Motor trajectory for requested fly is from "
+                f"{fly_prepared_position}{egu} to "
+                f"{self._fly_completed_position}{egu} but motor limits are "
+                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+            )
+        return fly_prepared_position

ophyd_async/panda/__init__.py

@@ -1,7 +1,10 @@
 from ._common_blocks import (
     CommonPandaBlocks,
     DataBlock,
+    EnableDisableOptions,
     PcapBlock,
+    PcompBlock,
+    PcompDirectionOptions,
     PulseBlock,
     SeqBlock,
     TimeUnits,
@@ -15,17 +18,27 @@ from ._table import (
     seq_table_from_arrays,
     seq_table_from_rows,
 )
-from ._trigger import StaticSeqTableTriggerLogic
+from ._trigger import (
+    PcompInfo,
+    SeqTableInfo,
+    StaticPcompTriggerLogic,
+    StaticSeqTableTriggerLogic,
+)
 from ._utils import phase_sorter
 
 __all__ = [
     "CommonPandaBlocks",
     "HDFPanda",
+    "PcompBlock",
+    "PcompInfo",
+    "PcompDirectionOptions",
+    "EnableDisableOptions",
     "PcapBlock",
     "PulseBlock",
     "seq_table_from_arrays",
     "seq_table_from_rows",
     "SeqBlock",
+    "SeqTableInfo",
     "SeqTable",
     "SeqTableRow",
     "SeqTrigger",
@@ -35,4 +48,5 @@ __all__ = [
     "DataBlock",
     "CommonPandABlocks",
     "StaticSeqTableTriggerLogic",
+    "StaticPcompTriggerLogic",
 ]