ophyd-async 0.3a4__py3-none-any.whl → 0.3a6__py3-none-any.whl

ophyd_async/epics/motion/motor.py

@@ -1,10 +1,20 @@
 import asyncio
-import time
-from typing import Callable, List, Optional
 
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, ConfigSignal, HintedSignal, StandardReadable
+from ophyd_async.core import (
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+)
+from ophyd_async.core.signal import observe_value
+from ophyd_async.core.utils import (
+    DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    CalculateTimeout,
+    WatcherUpdate,
+)
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -40,55 +50,50 @@ class Motor(StandardReadable, Movable, Stoppable):
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
-    async def _move(
-        self, new_position: float, watchers: Optional[List[Callable]] = None
+    @WatchableAsyncStatus.wrap
+    async def set(
+        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
     ):
-        if watchers is None:
-            watchers = []
         self._set_success = True
-        start = time.monotonic()
-        old_position, units, precision = await asyncio.gather(
+        (
+            old_position,
+            units,
+            precision,
+            velocity,
+            acceleration_time,
+        ) = await asyncio.gather(
             self.user_setpoint.get_value(),
             self.motor_egu.get_value(),
             self.precision.get_value(),
+            self.velocity.get_value(),
+            self.acceleration_time.get_value(),
         )
-
-        def update_watchers(current_position: float):
-            for watcher in watchers:
-                watcher(
-                    name=self.name,
-                    current=current_position,
-                    initial=old_position,
-                    target=new_position,
-                    unit=units,
-                    precision=precision,
-                    time_elapsed=time.monotonic() - start,
-                )
-
-        self.user_readback.subscribe_value(update_watchers)
-        try:
-            await self.user_setpoint.set(new_position)
-        finally:
-            self.user_readback.clear_sub(update_watchers)
+        if timeout is CalculateTimeout:
+            assert velocity > 0, "Motor has zero velocity"
+            timeout = (
+                abs(new_position - old_position) / velocity
+                + 2 * acceleration_time
+                + DEFAULT_TIMEOUT
+            )
+        move_status = self.user_setpoint.set(new_position, wait=True, timeout=timeout)
+        async for current_position in observe_value(
+            self.user_readback, done_status=move_status
+        ):
+            yield WatcherUpdate(
+                current=current_position,
+                initial=old_position,
+                target=new_position,
+                name=self.name,
+                unit=units,
+                precision=precision,
+            )
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
 
-    def move(self, new_position: float, timeout: Optional[float] = None):
-        """Commandline only synchronous move of a Motor"""
-        from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
-
-        if in_bluesky_event_loop():
-            raise RuntimeError("Will deadlock run engine if run in a plan")
-        call_in_bluesky_event_loop(self._move(new_position), timeout)  # type: ignore
-
-    def set(self, new_position: float, timeout: Optional[float] = None) -> AsyncStatus:
-        watchers: List[Callable] = []
-        coro = asyncio.wait_for(self._move(new_position, watchers), timeout=timeout)
-        return AsyncStatus(coro, watchers)
-
     async def stop(self, success=False):
         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.motor_stop.trigger(wait=False)
-        await status
+        await self.motor_stop.trigger(wait=False)
+        # Trigger any callbacks
+        await self.user_readback._backend.put(await self.user_readback.get_value())

ophyd_async/epics/pvi/pvi.py

@@ -91,7 +91,7 @@ def _verify_common_blocks(entry: PVIEntry, common_device: Type[Device]):
         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"):
+        if sub_name.startswith("_") or sub_name == "parent":
             continue
         assert entry.sub_entries
         device_t, is_optional = _strip_union(sub_device)
@@ -161,7 +161,7 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
     sub_devices = (
         (field, field_type)
         for field, field_type in get_type_hints(device_t).items()
-        if field not in ("_name", "parent")
+        if not field.startswith("_") and field != "parent"
     )
 
     for device_name, device_cls in sub_devices:

ophyd_async/epics/signal/__init__.py

@@ -1,8 +1,15 @@
-from .signal import epics_signal_r, epics_signal_rw, epics_signal_w, epics_signal_x
+from .signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+    epics_signal_w,
+    epics_signal_x,
+)
 
 __all__ = [
     "epics_signal_r",
     "epics_signal_rw",
+    "epics_signal_rw_rbv",
     "epics_signal_w",
     "epics_signal_x",
 ]

ophyd_async/panda/__init__.py

@@ -15,6 +15,7 @@ from ._table import (
     seq_table_from_arrays,
     seq_table_from_rows,
 )
+from ._trigger import StaticSeqTableTriggerLogic
 from ._utils import phase_sorter
 
 __all__ = [
@@ -33,4 +34,5 @@ __all__ = [
     "TimeUnits",
     "DataBlock",
     "CommonPandABlocks",
+    "StaticSeqTableTriggerLogic",
 ]

ophyd_async/panda/writers/_hdf_writer.py

@@ -79,10 +79,10 @@ async def get_signals_marked_for_capture(
         capture_signals.keys(), capture_signals.values(), signal_values
     ):
         signal_path = signal_path.replace("_capture", "")
-        if (signal_value.value in iter(Capture)) and (signal_value.value != Capture.No):
+        if (signal_value in iter(Capture)) and (signal_value != Capture.No):
             signals_to_capture[signal_path] = CaptureSignalWrapper(
                 signal_object,
-                signal_value.value,
+                signal_value,
             )
 
     return signals_to_capture
@@ -126,7 +126,7 @@ class PandaHDFWriter(DetectorWriter):
                 str(info.root / info.resource_dir)
             ),
             self.panda_device.data.hdf_file_name.set(
-                f"{info.prefix}{self.panda_device.name}{info.suffix}",
+                f"{info.prefix}{self.panda_device.name}{info.suffix}.h5",
             ),
             self.panda_device.data.num_capture.set(0),
         )
@@ -149,7 +149,7 @@ class PandaHDFWriter(DetectorWriter):
                 else split_path[-2]
             )
 
-            for suffix in str(capture_signal.capture_type).split(" "):
+            for suffix in capture_signal.capture_type.split(" "):
                 self._datasets.append(
                     _HDFDataset(
                         name,

ophyd_async/plan_stubs/__init__.py

@@ -0,0 +1,13 @@
+from .ensure_connected import ensure_connected
+from .fly import (
+    fly_and_collect,
+    prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
+    time_resolved_fly_and_collect_with_static_seq_table,
+)
+
+__all__ = [
+    "fly_and_collect",
+    "prepare_static_seq_table_flyer_and_detectors_with_same_trigger",
+    "time_resolved_fly_and_collect_with_static_seq_table",
+    "ensure_connected",
+]

ophyd_async/plan_stubs/ensure_connected.py

@@ -0,0 +1,22 @@
+import bluesky.plan_stubs as bps
+
+from ophyd_async.core.device import Device
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, wait_for_connection
+
+
+def ensure_connected(
+    *devices: Device,
+    mock: bool = False,
+    timeout: float = DEFAULT_TIMEOUT,
+    force_reconnect=False,
+):
+    yield from bps.wait_for(
+        [
+            lambda: wait_for_connection(
+                **{
+                    device.name: device.connect(mock, timeout, force_reconnect)
+                    for device in devices
+                }
+            )
+        ]
+    )

ophyd_async/plan_stubs/fly.py

@@ -0,0 +1,149 @@
+from typing import List
+
+import bluesky.plan_stubs as bps
+from bluesky.utils import short_uid
+
+from ophyd_async.core.detector import DetectorTrigger, StandardDetector, TriggerInfo
+from ophyd_async.core.flyer import HardwareTriggeredFlyable
+from ophyd_async.core.utils import in_micros
+from ophyd_async.panda._table import SeqTable, SeqTableRow, seq_table_from_rows
+from ophyd_async.panda._trigger import SeqTableInfo
+
+
+def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
+    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    detectors: List[StandardDetector],
+    number_of_frames: int,
+    exposure: float,
+    shutter_time: float,
+    repeats: int = 1,
+    period: float = 0.0,
+):
+    """Prepare a hardware triggered flyable and one or more detectors.
+
+    Prepare a hardware triggered flyable and one or more detectors with the
+    same trigger. This method constructs TriggerInfo and a static sequence
+    table from required parameters. The table is required to prepare the flyer,
+    and the TriggerInfo is required to prepare the detector(s).
+
+    This prepares all supplied detectors with the same trigger.
+
+    """
+    if not detectors:
+        raise ValueError("No detectors provided. There must be at least one.")
+
+    deadtime = max(det.controller.get_deadtime(exposure) for det in detectors)
+
+    trigger_info = TriggerInfo(
+        num=number_of_frames * repeats,
+        trigger=DetectorTrigger.constant_gate,
+        deadtime=deadtime,
+        livetime=exposure,
+    )
+    trigger_time = number_of_frames * (exposure + deadtime)
+    pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
+
+    table: SeqTable = seq_table_from_rows(
+        # Wait for pre-delay then open shutter
+        SeqTableRow(
+            time1=in_micros(pre_delay),
+            time2=in_micros(shutter_time),
+            outa2=True,
+        ),
+        # Keeping shutter open, do N triggers
+        SeqTableRow(
+            repeats=number_of_frames,
+            time1=in_micros(exposure),
+            outa1=True,
+            outb1=True,
+            time2=in_micros(deadtime),
+            outa2=True,
+        ),
+        # Add the shutter close
+        SeqTableRow(time2=in_micros(shutter_time)),
+    )
+
+    table_info = SeqTableInfo(table, repeats)
+
+    for det in detectors:
+        yield from bps.prepare(det, trigger_info, wait=False, group="prep")
+    yield from bps.prepare(flyer, table_info, wait=False, group="prep")
+    yield from bps.wait(group="prep")
+
+
+def fly_and_collect(
+    stream_name: str,
+    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    detectors: List[StandardDetector],
+):
+    """Kickoff, complete and collect with a flyer and multiple detectors.
+
+    This stub takes a flyer and one or more detectors that have been prepared. It
+    declares a stream for the detectors, then kicks off the detectors and the flyer.
+    The detectors are collected until the flyer and detectors have completed.
+
+    """
+    yield from bps.declare_stream(*detectors, name=stream_name, collect=True)
+    yield from bps.kickoff(flyer, wait=True)
+    for detector in detectors:
+        yield from bps.kickoff(detector)
+
+    # collect_while_completing
+    group = short_uid(label="complete")
+
+    yield from bps.complete(flyer, wait=False, group=group)
+    for detector in detectors:
+        yield from bps.complete(detector, wait=False, group=group)
+
+    done = False
+    while not done:
+        try:
+            yield from bps.wait(group=group, timeout=0.5)
+        except TimeoutError:
+            pass
+        else:
+            done = True
+        yield from bps.collect(
+            *detectors,
+            return_payload=False,
+            name=stream_name,
+        )
+    yield from bps.wait(group=group)
+
+
+def time_resolved_fly_and_collect_with_static_seq_table(
+    stream_name: str,
+    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    detectors: List[StandardDetector],
+    number_of_frames: int,
+    exposure: float,
+    shutter_time: float,
+    repeats: int = 1,
+    period: float = 0.0,
+):
+    """Run a scan wth a flyer and multiple detectors.
+
+    The stub demonstrates the standard basic flow for a flyscan:
+
+    - Prepare the flyer and detectors with a trigger
+    - Fly and collect:
+       - Declare the stream and kickoff the scan
+       - Collect while completing
+
+    This needs to be used in a plan that instantates detectors and a flyer,
+    stages/unstages the devices, and opens and closes the run.
+
+    """
+
+    # Set up scan and prepare trigger
+    yield from prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
+        flyer,
+        detectors,
+        number_of_frames=number_of_frames,
+        exposure=exposure,
+        shutter_time=shutter_time,
+        repeats=repeats,
+        period=period,
+    )
+    # Run the fly scan
+    yield from fly_and_collect(stream_name, flyer, detectors)

ophyd_async/protocols.py

@@ -1,9 +1,20 @@
+from __future__ import annotations
+
 from abc import abstractmethod
-from typing import Dict, Protocol, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generic,
+    Protocol,
+    TypeVar,
+    runtime_checkable,
+)
 
 from bluesky.protocols import DataKey, HasName, Reading
 
-from ophyd_async.core.async_status import AsyncStatus
+if TYPE_CHECKING:
+    from ophyd_async.core.async_status import AsyncStatus
 
 
 @runtime_checkable
@@ -94,3 +105,22 @@ class AsyncStageable(Protocol):
         unstaging.
         """
         ...
+
+
+C = TypeVar("C", contravariant=True)
+
+
+class Watcher(Protocol, Generic[C]):
+    @staticmethod
+    def __call__(
+        *,
+        current: C,
+        initial: C,
+        target: C,
+        name: str | None,
+        unit: str | None,
+        precision: float | None,
+        fraction: float | None,
+        time_elapsed: float | None,
+        time_remaining: float | None,
+    ) -> Any: ...

ophyd_async/sim/demo/sim_motor.py

@@ -1,13 +1,18 @@
 import asyncio
+import contextlib
 import time
-from typing import Callable, List, Optional
 
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import StandardReadable
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.signal import soft_signal_r_and_setter, soft_signal_rw
+from ophyd_async.core.async_status import AsyncStatus, WatchableAsyncStatus
+from ophyd_async.core.signal import (
+    observe_value,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
 from ophyd_async.core.standard_readable import ConfigSignal, HintedSignal
+from ophyd_async.core.utils import WatcherUpdate
 
 
 class SimMotor(StandardReadable, Movable, Stoppable):
@@ -20,99 +25,79 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         - name: str: name of device
         - instant: bool: whether to move instantly, or with a delay
         """
+        # Define some signals
         with self.add_children_as_readables(HintedSignal):
             self.user_readback, self._user_readback_set = soft_signal_r_and_setter(
                 float, 0
             )
-
         with self.add_children_as_readables(ConfigSignal):
-            self.velocity = soft_signal_rw(float, 1.0)
-            self.egu = soft_signal_rw(float, "mm")
-
-        self._instant = instant
-        self._move_task: Optional[asyncio.Task] = None
-
-        # Define some signals
+            self.velocity = soft_signal_rw(float, 0 if instant else 1.0)
+            self.units = soft_signal_rw(str, "mm")
         self.user_setpoint = soft_signal_rw(float, 0)
 
-        super().__init__(name=name)
-
         # Whether set() should complete successfully or not
         self._set_success = True
+        self._move_status: AsyncStatus | None = None
 
-    def stop(self, success=False):
-        """
-        Stop the motor if it is moving
-        """
-        if self._move_task:
-            self._move_task.cancel()
-            self._move_task = None
+        super().__init__(name=name)
 
-        self._set_success = success
+    async def _move(self, old_position: float, new_position: float, move_time: float):
+        start = time.monotonic()
+        distance = abs(new_position - old_position)
+        while True:
+            time_elapsed = round(time.monotonic() - start, 2)
 
-    def set(self, new_position: float, timeout: Optional[float] = None) -> AsyncStatus:  # noqa: F821
-        """
-        Asynchronously move the motor to a new position.
-        """
-        watchers: List[Callable] = []
-        coro = asyncio.wait_for(self._move(new_position, watchers), timeout=timeout)
-        return AsyncStatus(coro, watchers)
+            # update position based on time elapsed
+            if time_elapsed >= move_time:
+                # successfully reached our target position
+                self._user_readback_set(new_position)
+                break
+            else:
+                current_position = old_position + distance * time_elapsed / move_time
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
-        """
-        Start the motor moving to a new position.
+            self._user_readback_set(current_position)
 
-        If the motor is already moving, it will stop first.
-        If this is an instant motor the move will be instantaneous.
-        """
-        self.stop()
-        start = time.monotonic()
-
-        current_position = await self.user_readback.get_value()
-        distance = abs(new_position - current_position)
-        travel_time = 0 if self._instant else distance / await self.velocity.get_value()
+            # 10hz update loop
+            await asyncio.sleep(0.1)
 
-        old_position, units = await asyncio.gather(
+    @WatchableAsyncStatus.wrap
+    async def set(self, new_position: float):
+        """
+        Asynchronously move the motor to a new position.
+        """
+        # Make sure any existing move tasks are stopped
+        await self.stop()
+        old_position, units, velocity = await asyncio.gather(
             self.user_setpoint.get_value(),
-            self.egu.get_value(),
+            self.units.get_value(),
+            self.velocity.get_value(),
         )
-
-        async def update_position():
-            while True:
-                time_elapsed = round(time.monotonic() - start, 2)
-
-                # update position based on time elapsed
-                if time_elapsed >= travel_time:
-                    # successfully reached our target position
-                    self._user_readback_set(new_position)
-                    self._set_success = True
-                    break
-                else:
-                    current_position = (
-                        old_position + distance * time_elapsed / travel_time
-                    )
-
-                self._user_readback_set(current_position)
-
-                # notify watchers of the new position
-                for watcher in watchers:
-                    watcher(
-                        name=self.name,
-                        current=current_position,
-                        initial=old_position,
-                        target=new_position,
-                        unit=units,
-                        time_elapsed=time.monotonic() - start,
-                    )
-
-                # 10hz update loop
-                await asyncio.sleep(0.1)
-
-        # set up a task that updates the motor position at 10hz
-        self._move_task = asyncio.create_task(update_position())
-
-        try:
-            await self._move_task
-        finally:
-            if not self._set_success:
-                raise RuntimeError("Motor was stopped")
+        # If zero velocity, do instant move
+        move_time = abs(new_position - old_position) / velocity if velocity else 0
+        self._move_status = AsyncStatus(
+            self._move(old_position, new_position, move_time)
+        )
+        # If stop is called then this will raise a CancelledError, ignore it
+        with contextlib.suppress(asyncio.CancelledError):
+            async for current_position in observe_value(
+                self.user_readback, done_status=self._move_status
+            ):
+                yield WatcherUpdate(
+                    current=current_position,
+                    initial=old_position,
+                    target=new_position,
+                    name=self.name,
+                    unit=units,
+                )
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
+
+    async def stop(self, success=True):
+        """
+        Stop the motor if it is moving
+        """
+        self._set_success = success
+        if self._move_status:
+            self._move_status.task.cancel()
+            self._move_status = None
+        await self.user_setpoint.set(await self.user_readback.get_value())

{ophyd_async-0.3a4.dist-info → ophyd_async-0.3a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a4
+Version: 0.3a6
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License