ophyd-async 0.10.1__py3-none-any.whl → 0.12__py3-none-any.whl

ophyd_async/plan_stubs/_fly.py

@@ -1,204 +0,0 @@
-import bluesky.plan_stubs as bps
-from bluesky.utils import short_uid
-
-from ophyd_async.core import (
-    DetectorTrigger,
-    StandardDetector,
-    StandardFlyer,
-    TriggerInfo,
-    in_micros,
-)
-from ophyd_async.fastcs.panda import (
-    PandaPcompDirection,
-    PcompInfo,
-    SeqTable,
-    SeqTableInfo,
-)
-
-
-def prepare_static_pcomp_flyer_and_detectors(
-    flyer: StandardFlyer[PcompInfo],
-    detectors: list[StandardDetector],
-    pcomp_info: PcompInfo,
-    trigger_info: TriggerInfo,
-):
-    """Prepare a hardware triggered flyable and one or more detectors.
-
-    Prepare a hardware triggered flyable and one or more detectors with the
-    same trigger.
-
-    """
-    for det in detectors:
-        yield from bps.prepare(det, trigger_info, wait=False, group="prep")
-    yield from bps.prepare(flyer, pcomp_info, wait=False, group="prep")
-    yield from bps.wait(group="prep")
-
-
-def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
-    flyer: StandardFlyer[SeqTableInfo],
-    detectors: list[StandardDetector],
-    number_of_frames: int,
-    exposure: float,
-    shutter_time: float,
-    repeats: int = 1,
-    period: float = 0.0,
-    frame_timeout: float | None = None,
-):
-    """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)  # noqa: SLF001
-
-    trigger_info = TriggerInfo(
-        number_of_events=number_of_frames * repeats,
-        trigger=DetectorTrigger.CONSTANT_GATE,
-        deadtime=deadtime,
-        livetime=exposure,
-        exposure_timeout=frame_timeout,
-    )
-    trigger_time = number_of_frames * (exposure + deadtime)
-    pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
-
-    table = (
-        # Wait for pre-delay then open shutter
-        SeqTable.row(
-            time1=in_micros(pre_delay),
-            time2=in_micros(shutter_time),
-            outa2=True,
-        )
-        +
-        # Keeping shutter open, do N triggers
-        SeqTable.row(
-            repeats=number_of_frames,
-            time1=in_micros(exposure),
-            outa1=True,
-            outb1=True,
-            time2=in_micros(deadtime),
-            outa2=True,
-        )
-        +
-        # Add the shutter close
-        SeqTable.row(time2=in_micros(shutter_time))
-    )
-
-    table_info = SeqTableInfo(sequence_table=table, repeats=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: StandardFlyer[SeqTableInfo] | StandardFlyer[PcompInfo],
-    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 fly_and_collect_with_static_pcomp(
-    stream_name: str,
-    flyer: StandardFlyer[PcompInfo],
-    detectors: list[StandardDetector],
-    number_of_pulses: int,
-    pulse_width: int,
-    rising_edge_step: int,
-    direction: PandaPcompDirection,
-    trigger_info: TriggerInfo,
-):
-    # Set up scan and prepare trigger
-    pcomp_info = PcompInfo(
-        start_postion=0,
-        pulse_width=pulse_width,
-        rising_edge_step=rising_edge_step,
-        number_of_pulses=number_of_pulses,
-        direction=direction,
-    )
-    yield from prepare_static_pcomp_flyer_and_detectors(
-        flyer, detectors, pcomp_info, trigger_info
-    )
-
-    # Run the fly scan
-    yield from fly_and_collect(stream_name, flyer, detectors)
-
-
-def time_resolved_fly_and_collect_with_static_seq_table(
-    stream_name: str,
-    flyer: StandardFlyer[SeqTableInfo],
-    detectors: list[StandardDetector],
-    number_of_frames: int,
-    exposure: float,
-    shutter_time: float,
-    repeats: int = 1,
-    period: float = 0.0,
-    frame_timeout: float | None = None,
-):
-    """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,
-        frame_timeout=frame_timeout,
-    )
-    # Run the fly scan
-    yield from fly_and_collect(stream_name, flyer, detectors)

ophyd_async/sim/__init__.py

@@ -8,14 +8,13 @@ from ._mirror_vertical import (
     TwoJackTransform,
     VerticalMirror,
 )
-from ._motor import FlySimMotorInfo, SimMotor
+from ._motor import SimMotor
 from ._pattern_generator import PatternGenerator
 from ._point_detector import SimPointDetector
 from ._stage import SimStage
 
 __all__ = [
     "SimMotor",
-    "FlySimMotorInfo",
     "SimStage",
     "PatternGenerator",
     "SimPointDetector",

ophyd_async/sim/_blob_detector_writer.py

@@ -52,7 +52,7 @@ class BlobDetectorWriter(DetectorWriter):
                 chunk_shape=(1024,),
             ),
         ]
-        self.composer = None
+        self.composer = HDFDocumentComposer(self.path, self.datasets)
         describe = {
             ds.data_key: DataKey(
                 source="sim://pattern-generator-hdf-file",
@@ -85,17 +85,11 @@ class BlobDetectorWriter(DetectorWriter):
         self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         # When we have written something to the file
-        if indices_written:
-            # Only emit stream resource the first time we see frames in
-            # the file
-            if not self.composer:
-                if not self.path:
-                    raise RuntimeError(f"open() not called on {self}")
-                self.composer = HDFDocumentComposer(self.path, self.datasets)
-                for doc in self.composer.stream_resources():
-                    yield "stream_resource", doc
-            for doc in self.composer.stream_data(indices_written):
-                yield "stream_datum", doc
+        if self.composer is None:
+            msg = f"open() not called on {self}"
+            raise RuntimeError(msg)
+        for doc in self.composer.make_stream_docs(indices_written):
+            yield doc
 
     async def close(self) -> None:
         self.pattern_generator.close_file()

ophyd_async/sim/_mirror_horizontal.py

@@ -3,7 +3,7 @@ from typing import TypedDict
 
 from bluesky.protocols import Movable
 
-from ophyd_async.core import AsyncStatus, DerivedSignalFactory, Device, soft_signal_rw
+from ophyd_async.core import AsyncStatus, DerivedSignalFactory, Device
 
 from ._mirror_vertical import TwoJackDerived, TwoJackTransform
 from ._motor import SimMotor
@@ -20,7 +20,8 @@ class HorizontalMirror(Device, Movable):
         self.x1 = SimMotor()
         self.x2 = SimMotor()
         # Parameter
-        self.x1_x2_distance = soft_signal_rw(float, initial_value=1)
+        # This could also be set as 'soft_signal_rw(float, initial_value=1)'
+        self.x1_x2_distance = 1.0
         # Derived signals
         self._factory = DerivedSignalFactory(
             TwoJackTransform,

ophyd_async/sim/_mirror_vertical.py

@@ -51,6 +51,7 @@ class VerticalMirror(Device, Movable[TwoJackDerived]):
         self.y1 = SimMotor()
         self.y2 = SimMotor()
         # Parameter
+        # This could also be set as '1.0', if constant.
         self.y1_y2_distance = soft_signal_rw(float, initial_value=1)
         # Derived signals
         self._factory = DerivedSignalFactory(

ophyd_async/sim/_motor.py

@@ -4,14 +4,15 @@ import time
 
 import numpy as np
 from bluesky.protocols import Locatable, Location, Reading, Stoppable, Subscribable
-from pydantic import BaseModel, ConfigDict, Field
 
 from ophyd_async.core import (
     AsyncStatus,
     Callback,
+    FlyMotorInfo,
     StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
+    error_if_none,
     observe_value,
     soft_signal_r_and_setter,
     soft_signal_rw,
@@ -19,37 +20,6 @@ from ophyd_async.core import (
 from ophyd_async.core import StandardReadableFormat as Format
 
 
-class FlySimMotorInfo(BaseModel):
-    """Minimal set of information required to fly a [](#SimMotor)."""
-
-    model_config = ConfigDict(frozen=True)
-
-    cv_start: float
-    """Absolute position of the motor once it finishes accelerating to desired
-    velocity, in motor EGUs"""
-
-    cv_end: float
-    """Absolute position of the motor once it begins decelerating from desired
-    velocity, in EGUs"""
-
-    cv_time: float = Field(gt=0)
-    """Time taken for the motor to get from start_position to end_position, excluding
-    run-up and run-down, in seconds."""
-
-    @property
-    def velocity(self) -> float:
-        """Calculate the velocity of the constant velocity phase."""
-        return (self.cv_end - self.cv_start) / self.cv_time
-
-    def start_position(self, acceleration_time: float) -> float:
-        """Calculate the start position with run-up distance added on."""
-        return self.cv_start - acceleration_time * self.velocity / 2
-
-    def end_position(self, acceleration_time: float) -> float:
-        """Calculate the end position with run-down distance added on."""
-        return self.cv_end + acceleration_time * self.velocity / 2
-
-
 class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float]):
     """For usage when simulating a motor."""
 
@@ -74,7 +44,7 @@ class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float
         self._set_success = True
         self._move_status: AsyncStatus | None = None
         # Stored in prepare
-        self._fly_info: FlySimMotorInfo | None = None
+        self._fly_info: FlyMotorInfo | None = None
         # Set on kickoff(), complete when motor reaches end position
         self._fly_status: WatchableAsyncStatus | None = None
 
@@ -86,12 +56,14 @@ class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float
         self.user_readback.set_name(name)
 
     @AsyncStatus.wrap
-    async def prepare(self, value: FlySimMotorInfo):
+    async def prepare(self, value: FlyMotorInfo):
         """Calculate run-up and move there, setting fly velocity when there."""
         self._fly_info = value
         # Move to start as fast as we can
         await self.velocity.set(0)
-        await self.set(value.start_position(await self.acceleration_time.get_value()))
+        await self.set(
+            value.ramp_up_start_pos(await self.acceleration_time.get_value())
+        )
         # Set the velocity for the actual move
         await self.velocity.set(value.velocity)
 
@@ -111,20 +83,18 @@ class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float
     @AsyncStatus.wrap
     async def kickoff(self):
         """Begin moving motor from prepared position to final position."""
-        if not self._fly_info:
-            msg = "Motor must be prepared before attempting to kickoff"
-            raise RuntimeError(msg)
+        fly_info = error_if_none(
+            self._fly_info, "Motor must be prepared before attempting to kickoff"
+        )
         acceleration_time = await self.acceleration_time.get_value()
-        self._fly_status = self.set(self._fly_info.end_position(acceleration_time))
+        self._fly_status = self.set(fly_info.ramp_down_end_pos(acceleration_time))
         # Wait for the acceleration time to ensure we are at velocity
         await asyncio.sleep(acceleration_time)
 
     def complete(self) -> WatchableAsyncStatus:
         """Mark as complete once motor reaches completed position."""
-        if not self._fly_status:
-            msg = "kickoff not called"
-            raise RuntimeError(msg)
-        return self._fly_status
+        fly_status = error_if_none(self._fly_status, "kickoff not called")
+        return fly_status
 
     async def _move(self, old_position: float, new_position: float, velocity: float):
         if old_position == new_position:

ophyd_async/testing/__init__.py

@@ -11,6 +11,7 @@ from ._assert import (
     assert_emitted,
     assert_reading,
     assert_value,
+    partial_reading,
 )
 from ._mock_signal_utils import (
     callback_on_mock_put,
@@ -47,6 +48,7 @@ __all__ = [
     "assert_configuration",
     "assert_describe_signal",
     "assert_emitted",
+    "partial_reading",
     # Mocking utilities
     "get_mock",
     "set_mock_value",

ophyd_async/testing/_assert.py

@@ -21,6 +21,15 @@ from ophyd_async.core import (
 from ._utils import T
 
 
+def partial_reading(val: Any) -> dict[str, Any]:
+    """Helper function for building expected reading or configuration dicts.
+
+    :param val: Value to be wrapped in dict with "value" as the key.
+    :return: The dict that has wrapped the val with key "value".
+    """
+    return {"value": val}
+
+
 def approx_value(value: Any):
     """Allow any value to be compared to another in tests.
 
@@ -45,14 +54,18 @@ async def assert_value(signal: SignalR[SignalDatatypeT], value: Any) -> None:
 async def assert_reading(
     readable: AsyncReadable,
     expected_reading: Mapping[str, Mapping[str, Any]],
+    full_match: bool = True,
 ) -> None:
     """Assert that a readable Device has the given reading.
 
     :param readable: Device with an async ``read()`` method to get the reading from.
     :param expected_reading: The expected reading from the readable.
+    :param full_match: if expected_reading keys set is same as actual keys set.
+        true: exact match
+        false: expected_reading keys is subset of actual reading keys
     """
     actual_reading = await readable.read()
-    _assert_readings_approx_equal(expected_reading, actual_reading)
+    _assert_readings_approx_equal(expected_reading, actual_reading, full_match)
 
 
 def _approx_reading(expected: Mapping[str, Any], actual: Reading) -> Reading:
@@ -69,16 +82,26 @@ def _approx_reading(expected: Mapping[str, Any], actual: Reading) -> Reading:
 
 
 def _assert_readings_approx_equal(
-    expected: Mapping[str, Mapping[str, Any]], actual: Mapping[str, Reading]
+    expected: Mapping[str, Mapping[str, Any]],
+    actual: Mapping[str, Reading],
+    full_match: bool = True,
 ):
-    assert actual == {
-        k: _approx_reading(v, actual[k]) for k, v in expected.items() if k in actual
+    # expand the expected keys to include actual if we allow partial matches
+    if not full_match:
+        expected = dict(actual, **expected)
+    # now make them approximate if they are in actual so we get a nicer diff
+    approx_expected = {
+        k: _approx_reading(v, actual[k]) if k in actual else v
+        for k, v in expected.items()
     }
+    # now we can compare them
+    assert actual == approx_expected
 
 
 async def assert_configuration(
     configurable: AsyncConfigurable,
-    configuration: dict[str, dict[str, Any]],
+    expected_configuration: dict[str, dict[str, Any]],
+    full_match: bool = True,
 ) -> None:
     """Assert that a configurable Device has the given configuration.
 
@@ -86,9 +109,14 @@ async def assert_configuration(
         Device with an async ``read_configuration()`` method to get the
         configuration from.
     :param configuration: The expected configuration from the configurable.
+    :param full_match: if expected_reading keys set is same as actual keys set.
+        true: exact match
+        false: expected_reading keys is subset of actual reading keys
     """
     actual_configuration = await configurable.read_configuration()
-    _assert_readings_approx_equal(configuration, actual_configuration)
+    _assert_readings_approx_equal(
+        expected_configuration, actual_configuration, full_match
+    )
 
 
 async def assert_describe_signal(signal: SignalR, /, **metadata):

{ophyd_async-0.10.1.dist-info → ophyd_async-0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.1
+Version: 0.12
 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
@@ -48,6 +48,7 @@ Requires-Dist: pyyaml
 Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
+Requires-Dist: stamina>=23.1.0
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
@@ -70,7 +71,7 @@ Requires-Dist: inflection; extra == "dev"
 Requires-Dist: import-linter; extra == "dev"
 Requires-Dist: myst-parser; extra == "dev"
 Requires-Dist: numpydoc; extra == "dev"
-Requires-Dist: ophyd; extra == "dev"
+Requires-Dist: ophyd>=1.10.7; extra == "dev"
 Requires-Dist: pickleshare; extra == "dev"
 Requires-Dist: pipdeptree; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
@@ -120,7 +121,7 @@ The main differences from ophyd sync are:
 - Support for [EPICS][] PVA and [Tango][] as well as the traditional EPICS CA
 - Better library support for splitting the logic from the hardware interface to avoid complex class heirarchies
 
-It was written with the aim of implementing flyscanning in a generic and extensible way with highly customizable devices like PandABox and the Delta Tau PMAC products. Using async code makes it possible to do the "put 3 PVs in parallel, then get from another PV" logic that is common in flyscanning without the performance and complexity overhead of multiple threads.
+It was written with the aim of implementing fly scanning in a generic and extensible way with highly customizable devices like PandABox and the Delta Tau PMAC products. Using async code makes it possible to do the "put 3 PVs in parallel, then get from another PV" logic that is common in fly scanning without the performance and complexity overhead of multiple threads.
 
 Devices from both ophyd sync and ophyd-async can be used in the same RunEngine and even in the same scan. This allows a per-device migration where devices are reimplemented in ophyd-async one by one.