ophyd-async 0.10.0a4__py3-none-any.whl → 0.11__py3-none-any.whl

ophyd_async/epics/motor.py

@@ -14,7 +14,6 @@ from bluesky.protocols import (
     Stoppable,
     Subscribable,
 )
-from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
     CALCULATE_TIMEOUT,
@@ -22,16 +21,18 @@ from ophyd_async.core import (
     AsyncStatus,
     CalculatableTimeout,
     Callback,
+    FlyMotorInfo,
     StandardReadable,
     StrictEnum,
     WatchableAsyncStatus,
     WatcherUpdate,
+    error_if_none,
     observe_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
-__all__ = ["MotorLimitsException", "FlyMotorInfo", "Motor"]
+__all__ = ["MotorLimitsException", "Motor"]
 
 
 class MotorLimitsException(Exception):
@@ -40,26 +41,6 @@ class MotorLimitsException(Exception):
     pass
 
 
-class FlyMotorInfo(BaseModel):
-    """Minimal set of information required to fly a motor."""
-
-    start_position: float = Field(frozen=True)
-    """Absolute position of the motor once it finishes accelerating to desired
-    velocity, in motor EGUs"""
-
-    end_position: float = Field(frozen=True)
-    """Absolute position of the motor once it begins decelerating from desired
-    velocity, in EGUs"""
-
-    time_for_move: float = Field(frozen=True, gt=0)
-    """Time taken for the motor to get from start_position to end_position, excluding
-    run-up and run-down, in seconds."""
-
-    timeout: CalculatableTimeout = Field(frozen=True, default=CALCULATE_TIMEOUT)
-    """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."""
-
-
 class OffsetMode(StrictEnum):
     VARIABLE = "Variable"
     FROZEN = "Frozen"
@@ -111,15 +92,12 @@ class Motor(
         # 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: float | None = None
+        # Currently requested fly info, stored in prepare
+        self._fly_info: FlyMotorInfo | None = None
 
         # Set on kickoff(), complete when motor reaches self._fly_completed_position
         self._fly_status: WatchableAsyncStatus | None = None
 
-        # Set during prepare
-        self._fly_timeout: CalculatableTimeout | None = CALCULATE_TIMEOUT
-
         super().__init__(name=name)
 
     def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
@@ -131,41 +109,64 @@ class Motor(
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
         """Move to the beginning of a suitable run-up distance ready for a flyscan."""
-        self._fly_timeout = value.timeout
+        self._fly_info = value
 
         # 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,
+        max_speed, egu = await asyncio.gather(
+            self.max_velocity.get_value(), self.motor_egu.get_value()
         )
+        if abs(value.velocity) > max_speed:
+            raise MotorLimitsException(
+                f"Velocity {abs(value.velocity)} {egu}/s was requested for a motor "
+                f" with max speed of {max_speed} {egu}/s"
+            )
+
+        acceleration_time = await self.acceleration_time.get_value()
+        ramp_up_start_pos = value.ramp_up_start_pos(acceleration_time)
+        ramp_down_end_pos = value.ramp_down_end_pos(acceleration_time)
 
-        # 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
+        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(),
         )
 
-        await self.set(fly_prepared_position)
-        await self.velocity.set(abs(fly_velocity))
+        if (
+            not motor_upper_limit >= ramp_up_start_pos >= motor_lower_limit
+            or not motor_upper_limit >= ramp_down_end_pos >= motor_lower_limit
+        ):
+            raise MotorLimitsException(
+                f"Motor trajectory for requested fly is from "
+                f"{ramp_up_start_pos}{egu} to "
+                f"{ramp_down_end_pos}{egu} but motor limits are "
+                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+            )
+
+        # move to prepare position at maximum velocity
+        await self.velocity.set(abs(max_speed))
+        await self.set(ramp_up_start_pos)
+
+        # Set velocity we will be using for the flyscan
+        await self.velocity.set(abs(value.velocity))
 
     @AsyncStatus.wrap
     async def kickoff(self):
         """Begin moving motor from prepared position to final position."""
-        if not self._fly_completed_position:
-            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_completed_position, timeout=self._fly_timeout
+            fly_info.ramp_down_end_pos(acceleration_time),
+            timeout=fly_info.timeout,
         )
 
     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
 
     @WatchableAsyncStatus.wrap
     async def set(  # type: ignore
@@ -220,22 +221,6 @@ class Motor(
         # the move above, so need to pass wait=False
         await self.motor_stop.set(1, wait=False)
 
-    async def _prepare_velocity(
-        self, start_position: float, end_position: float, time_for_move: float
-    ) -> float:
-        fly_velocity = (end_position - start_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"
-            )
-        # move to prepare position at maximum velocity
-        await self.velocity.set(abs(max_speed))
-        return fly_velocity
-
     async def locate(self) -> Location[float]:
         """Return the current setpoint and readback of the motor."""
         setpoint, readback = await asyncio.gather(
@@ -250,38 +235,3 @@ class Motor(
     def clear_sub(self, function: Callback[dict[str, Reading[float]]]) -> None:
         """Unsubscribe."""
         self.user_readback.clear_sub(function)
-
-    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 * 0.5
-        )
-
-        direction = 1 if end_position > start_position else -1
-        self._fly_completed_position = end_position + (run_up_distance * direction)
-
-        # Prepared position not used after prepare, so no need to store in self
-        fly_prepared_position = start_position - (run_up_distance * direction)
-
-        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/epics/pmac/__init__.py

@@ -0,0 +1,3 @@
+from ._pmac_io import PmacAxisIO, PmacCoordIO, PmacIO, PmacTrajectoryIO
+
+__all__ = ["PmacAxisIO", "PmacCoordIO", "PmacIO", "PmacTrajectoryIO"]

ophyd_async/epics/pmac/_pmac_io.py

@@ -0,0 +1,100 @@
+from collections.abc import Sequence
+
+import numpy as np
+
+from ophyd_async.core import Array1D, Device, DeviceVector, StandardReadable
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+CS_LETTERS = "ABCUVWXYZ"
+
+
+class PmacTrajectoryIO(StandardReadable):
+    """Device that moves a PMAC Motor record."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.time_array = epics_signal_rw(
+            Array1D[np.float64], prefix + ":ProfileTimeArray"
+        )
+        self.user_array = epics_signal_rw(Array1D[np.int32], prefix + ":UserArray")
+        # 1 indexed CS axes so we can index into them from the compound motor input link
+        self.positions = DeviceVector(
+            {
+                i + 1: epics_signal_rw(
+                    Array1D[np.float64], f"{prefix}:{letter}:Positions"
+                )
+                for i, letter in enumerate(CS_LETTERS)
+            }
+        )
+        self.use_axis = DeviceVector(
+            {
+                i + 1: epics_signal_rw(bool, f"{prefix}:{letter}:UseAxis")
+                for i, letter in enumerate(CS_LETTERS)
+            }
+        )
+        self.velocities = DeviceVector(
+            {
+                i + 1: epics_signal_rw(
+                    Array1D[np.float64], f"{prefix}:{letter}:Velocities"
+                )
+                for i, letter in enumerate(CS_LETTERS)
+            }
+        )
+        self.points_to_build = epics_signal_rw(int, prefix + ":ProfilePointsToBuild")
+        self.build_profile = epics_signal_rw(bool, prefix + ":ProfileBuild")
+        self.execute_profile = epics_signal_rw(bool, prefix + ":ProfileExecute")
+        self.scan_percent = epics_signal_r(float, prefix + ":TscanPercent_RBV")
+        self.abort_profile = epics_signal_rw(bool, prefix + ":ProfileAbort")
+        self.profile_cs_name = epics_signal_rw(str, prefix + ":ProfileCsName")
+        self.calculate_velocities = epics_signal_rw(bool, prefix + ":ProfileCalcVel")
+
+        super().__init__(name=name)
+
+
+class PmacAxisIO(Device):
+    """A Device that (direct) moves a PMAC Coordinate System Motor.
+
+    Note that this does not go through a motor record.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.cs_axis_letter = epics_signal_r(str, f"{prefix}:CsAxis_RBV")
+        self.cs_port = epics_signal_r(str, f"{prefix}:CsPort_RBV")
+        super().__init__(name=name)
+
+
+class PmacCoordIO(Device):
+    """A Device that represents a Pmac Coordinate System."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.defer_moves = epics_signal_r(bool, f"{prefix}:DeferMoves")
+        self.cs_axis_setpoint = DeviceVector(
+            {
+                i + 1: epics_signal_rw(
+                    Array1D[np.float64], f"{prefix}:M{i + 1}:DirectDemand"
+                )
+                for i in range(len(CS_LETTERS))
+            }
+        )
+        super().__init__(name=name)
+
+
+class PmacIO(Device):
+    """Device that represents a pmac controller."""
+
+    def __init__(
+        self,
+        prefix: str,
+        axis_nums: Sequence[int],
+        coord_nums: Sequence[int],
+        name: str = "",
+    ) -> None:
+        self.axis = DeviceVector(
+            {axis: PmacAxisIO(f"{prefix}:M{axis}") for axis in axis_nums}
+        )
+        self.coord = DeviceVector(
+            {coord: PmacCoordIO(f"{prefix}:CS{coord}") for coord in coord_nums}
+        )
+        # Trajectory PVs have the same prefix as the pmac device
+        self.trajectory = PmacTrajectoryIO(prefix)
+
+        super().__init__(name=name)

ophyd_async/fastcs/eiger/__init__.py

@@ -1,4 +1,4 @@
-from ._eiger import EigerDetector, EigerTriggerInfo
+from ._eiger import EigerDetector
 from ._eiger_controller import EigerController
 from ._eiger_io import EigerDetectorIO, EigerDriverIO, EigerMonitorIO, EigerStreamIO
 
@@ -6,7 +6,6 @@ __all__ = [
     "EigerDetector",
     "EigerController",
     "EigerDriverIO",
-    "EigerTriggerInfo",
     "EigerDetectorIO",
     "EigerMonitorIO",
     "EigerStreamIO",

ophyd_async/fastcs/eiger/_eiger.py

@@ -1,5 +1,3 @@
-from pydantic import Field
-
 from ophyd_async.core import (
     AsyncStatus,
     PathProvider,
@@ -12,10 +10,6 @@ from ._eiger_controller import EigerController
 from ._eiger_io import EigerDriverIO
 
 
-class EigerTriggerInfo(TriggerInfo):
-    energy_ev: float = Field(gt=0)
-
-
 class EigerDetector(StandardDetector):
     """Ophyd-async implementation of an Eiger Detector."""
 
@@ -28,10 +22,11 @@ class EigerDetector(StandardDetector):
         path_provider: PathProvider,
         drv_suffix="-EA-EIGER-01:",
         hdf_suffix="-EA-EIGER-01:OD:",
+        odin_nodes: int = 4,
         name="",
     ):
         self.drv = EigerDriverIO(prefix + drv_suffix)
-        self.odin = Odin(prefix + hdf_suffix)
+        self.odin = Odin(prefix + hdf_suffix, nodes=odin_nodes)
 
         super().__init__(
             EigerController(self.drv),
@@ -44,6 +39,5 @@ class EigerDetector(StandardDetector):
         )
 
     @AsyncStatus.wrap
-    async def prepare(self, value: EigerTriggerInfo) -> None:  # type: ignore
-        await self._controller.set_energy(value.energy_ev)
+    async def prepare(self, value: TriggerInfo) -> None:
         await super().prepare(value)

ophyd_async/fastcs/panda/_trigger.py

@@ -1,8 +1,8 @@
 import asyncio
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 
-from ophyd_async.core import FlyerController, wait_for_value
+from ophyd_async.core import ConfinedModel, FlyerController, wait_for_value
 
 from ._block import (
     PandaBitMux,
@@ -14,7 +14,7 @@ from ._block import (
 from ._table import SeqTable
 
 
-class SeqTableInfo(BaseModel):
+class SeqTableInfo(ConfinedModel):
     """Info for the PandA `SeqTable` for flyscanning."""
 
     sequence_table: SeqTable = Field(strict=True)
@@ -51,7 +51,7 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
-class PcompInfo(BaseModel):
+class PcompInfo(ConfinedModel):
     """Info for the PandA `PcompBlock` for flyscanning."""
 
     start_postion: int = Field(description="start position in counts")

ophyd_async/fastcs/panda/_writer.py

@@ -33,12 +33,12 @@ class PandaHDFWriter(DetectorWriter):
 
     # Triggered on PCAP arm
     async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
+        self._composer = None
         """Retrieve and get descriptor of all PandA signals marked for capture."""
         self._exposures_per_event = exposures_per_event
         # Ensure flushes are immediate
         await self.panda_data_block.flush_period.set(0)
 
-        self._composer = None
         info = self._path_provider(device_name=name)
 
         # Set create dir depth first to guarantee that callback when setting
@@ -64,7 +64,15 @@ class PandaHDFWriter(DetectorWriter):
         # Wait for it to start, stashing the status that tells us when it finishes
         await self.panda_data_block.capture.set(True)
 
-        return await self._describe(name)
+        describe = await self._describe(name)
+
+        self._composer = HDFDocumentComposer(
+            Path(await self.panda_data_block.hdf_directory.get_value())
+            / Path(await self.panda_data_block.hdf_file_name.get_value()),
+            self._datasets,
+        )
+
+        return describe
 
     async def _describe(self, name: str) -> dict[str, DataKey]:
         """Return a describe based on the datasets PV."""
@@ -145,17 +153,11 @@ class PandaHDFWriter(DetectorWriter):
         self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
-        if indices_written:
-            if not self._composer:
-                self._composer = HDFDocumentComposer(
-                    Path(await self.panda_data_block.hdf_directory.get_value())
-                    / Path(await self.panda_data_block.hdf_file_name.get_value()),
-                    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
 
     # Could put this function as default for StandardDetector
     async def close(self):

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-0.10.0a4.dist-info → ophyd_async-0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a4
+Version: 0.11
 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
@@ -43,7 +43,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: bluesky>=1.13.1rc2
-Requires-Dist: event-model>=1.22.1
+Requires-Dist: event-model>=1.23
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
@@ -70,7 +70,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"