ophyd-async 0.13.1__tar.gz → 0.13.3__tar.gz

ophyd_async-0.13.3/.github/workflows/_system_test.yml

@@ -0,0 +1,38 @@
+on:
+  workflow_call:
+
+env:
+  # https://github.com/pytest-dev/pytest/issues/2042
+  PY_IGNORE_IMPORTMISMATCH: "1"
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          # Need this to get version number from last tag
+          fetch-depth: 0
+
+      - name: Install dev versions of python packages
+        uses: ./.github/actions/install_requirements
+
+      - name: Checkout simulated devices
+        uses: actions/checkout@v4
+        with:
+          repository: epics-containers/example-services
+          path: example-services
+          ref: 'main'
+
+      - name: Run docker compose
+        uses: hoverkraft-tech/compose-action@v2.3.0
+        with:
+          compose-file: "./example-services/compose.yaml"
+          services: |
+            bl01t-di-cam-01
+            ca-gateway
+
+      - name: Run system tests
+        run: pytest system_tests/epics/adsim

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/.github/workflows/ci.yml

@@ -38,6 +38,8 @@ jobs:
   docs:
     uses: ./.github/workflows/_docs.yml
 
+  system_tests:
+    uses: ./.github/workflows/_system_test.yml
 
   dist:
     uses: ./.github/workflows/_dist.yml
@@ -53,7 +55,7 @@ jobs:
     uses: ./.github/workflows/_codeql.yml
 
   release:
-    needs: [dist, test, docs]
+    needs: [dist, test, docs, system_tests]
     if: github.ref_type == 'tag'
     uses: ./.github/workflows/_release.yml
     permissions:

ophyd_async-0.13.3/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "example-services"]
+	path = example-services
+	url = https://github.com/epics-containers/example-services.git

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.1
+Version: 0.13.3
 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
@@ -49,7 +49,8 @@ Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Requires-Dist: stamina>=23.1.0
-Requires-Dist: scanspec>=1.0a1
+Requires-Dist: scanspec>=0.8
+Requires-Dist: velocity-profile
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
@@ -87,6 +88,7 @@ Requires-Dist: pytest-forked; extra == "dev"
 Requires-Dist: pytest-rerunfailures; extra == "dev"
 Requires-Dist: pytest-timeout; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
+Requires-Dist: scanspec>=1.0a1; extra == "dev"
 Requires-Dist: sphinx-autobuild; extra == "dev"
 Requires-Dist: sphinx-autodoc2; extra == "dev"
 Requires-Dist: sphinxcontrib-mermaid; extra == "dev"

ophyd_async-0.13.3/docs/explanations/when-to-extend-movable.md

@@ -0,0 +1,17 @@
+# When should a device extend movable
+
+The [`Movable`](#bluesky.protocols.Movable) protocol indicates that a device has a `set` method which can be called in the bluesky through the plan stubs [`bps.abs_set`](#bluesky.plan_stubs.abs_set) and [`bps.mv`](#bluesky.plan_stubs.mv). The [RunEngine](#bluesky.run_engine.RunEngine) treats this `set` as an atomic operation. A `Movable` device is appropriate when:
+
+- The `set` involves changing multiple signals in parallel alongside a desired ordering of the setting of signals - having this logic inside an asyncio function can provide speedup.
+
+- The `RunEngine` should not be altering any other devices while this `set` is taking place.
+
+- There is only one clear interpretation of what it means to set the device. For example, setting a motor is fairly unambiguous whereas setting a detector could mean a number of different things.
+
+- You are doing some logic that a user will almost always want to do with this device.
+
+The `set` method, in general, should be used be used with primitive values rather than more complex types, for example, dataclasses. Using the latter here leads to extra boilerplate at the plan level. An exception to this is where using `set` will provide speedup - in this case it could be worth the extra boilerplate.
+
+## What to use instead
+
+If the device doesn't satisfy the above criteria, it is generally more suitable to be using combinations of [`bps.mv`](#bluesky.plan_stubs.mv) and [`bps.abs_set`](#bluesky.plan_stubs.abs_set) on individual signals of a plan's devices. This avoids adding unnecessary complexity to the device whilst giving the plan more flexability.

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/docs/how-to/choose-right-baseclass.md

@@ -18,7 +18,7 @@ There are some utility baseclasses that allow you to create a Device pre-populat
 
 There are some [bluesky protocols](inv:bluesky#hardware) that show the verbs you can implement to add functionality in standard plans. For example:
 
-- [](#bluesky.protocols.Movable) to add behavior during `bps.mv` and `bps.abs_set`
+- [](#bluesky.protocols.Movable) to add behavior during `bps.mv` and `bps.abs_set`. See [here](../explanations/when-to-extend-movable.md) for deciding if a device should extend movable.
 - [](#bluesky.protocols.Triggerable) to add behavior before `read()` in `bps.scan`
 
 It is not strictly required to add the protocol class as a baseclass (the presence of a method with the right signature is all that is required) but generally this is done so that the IDE gives you help when filling in the method, and the type checker knows to check that you have filled it in correctly.

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/pyproject.toml

@@ -21,7 +21,8 @@ dependencies = [
     "pydantic>=2.0",
     "pydantic-numpy",
     "stamina>=23.1.0",
-    "scanspec>=1.0a1",
+    "scanspec>=0.8",
+    "velocity-profile",
 ]
 dynamic = ["version"]
 license.file = "LICENSE"
@@ -59,6 +60,7 @@ dev = [
     "pytest-rerunfailures",
     "pytest-timeout",
     "ruff",
+    "scanspec>=1.0a1",
     "sphinx-autobuild",
     "sphinx-autodoc2",
     "sphinxcontrib-mermaid",
@@ -103,7 +105,7 @@ markers = [
 ]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
-timeout = 0.75
+timeout = 1
 [tool.coverage.run]
 data_file = "/tmp/ophyd_async.coverage"
 

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/src/ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.1'
-__version_tuple__ = version_tuple = (0, 13, 1)
+__version__ = version = '0.13.3'
+__version_tuple__ = version_tuple = (0, 13, 3)
 
-__commit_id__ = commit_id = 'g228f25c8b'
+__commit_id__ = commit_id = 'gabcdf5983'

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/src/ophyd_async/core/__init__.py

@@ -6,7 +6,7 @@ from ._derived_signal import (
     derived_signal_rw,
     derived_signal_w,
 )
-from ._derived_signal_backend import Transform
+from ._derived_signal_backend import Transform, merge_gathered_dicts
 from ._detector import (
     DetectorController,
     DetectorTrigger,
@@ -212,6 +212,7 @@ __all__ = [
     "derived_signal_w",
     "Transform",
     "DerivedSignalFactory",
+    "merge_gathered_dicts",
     # Back compat - delete before 1.0
     "ConfigSignal",
     "HintedSignal",

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/src/ophyd_async/core/_signal.py

@@ -121,6 +121,13 @@ class _SignalCache(Generic[SignalDatatypeT]):
         self._valid = asyncio.Event()
         self._reading: Reading[SignalDatatypeT] | None = None
         self.backend: SignalBackend[SignalDatatypeT] = backend
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError as e:
+            raise RuntimeError(
+                "Need a running event loop to subscribe to a signal, "
+                "are you trying to run subscribe outside a plan?"
+            ) from e
         signal.log.debug(f"Making subscription on source {signal.source}")
         backend.set_callback(self._callback)
 

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/src/ophyd_async/epics/core/_epics_connector.py

@@ -10,7 +10,20 @@ from ._signal import EpicsSignalBackend, get_signal_backend_type, split_protocol
 
 @dataclass
 class PvSuffix:
-    """Define the PV suffix to be appended to the device prefix."""
+    """Define the PV suffix to be appended to the device prefix.
+
+    For a SignalRW:
+    - If you use the same "Suffix" for the read and write PV then use PvSuffix("Suffix")
+    - If you have "Suffix" for the write PV and "Suffix_RBV" for the read PV then use
+      PvSuffix.rbv("Suffix")
+    - If you have "WriteSuffix" for the write PV and "ReadSuffix" for the read PV then
+      you use PvSuffix(read_suffix="ReadSuffix", write_suffix="WriteSuffix")
+
+    For a SignalR:
+    - If you have "Suffix" for the read PV then use PvSuffix("Suffix")
+    - If you have "Suffix_RBV" for the read PV then use PvSuffix("Suffix_RBV"), do not
+      use PvSuffix.rbv as that will try to connect to multiple PVs
+    """
 
     read_suffix: str
     write_suffix: str | None = None

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/src/ophyd_async/epics/motor.py

@@ -106,6 +106,33 @@ class Motor(
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
+    async def check_motor_limit(self, abs_start_pos: float, abs_end_pos: float):
+        """Check the positions are within limits.
+
+        Will raise a MotorLimitsException if the given absolute positions will be
+        outside the motor soft limits.
+        """
+        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(),
+        )
+
+        # EPICS motor record treats limits of 0, 0 as no limit
+        if motor_lower_limit == 0 and motor_upper_limit == 0:
+            return
+
+        if (
+            not motor_upper_limit >= abs_start_pos >= motor_lower_limit
+            or not motor_upper_limit >= abs_end_pos >= motor_lower_limit
+        ):
+            raise MotorLimitsException(
+                f"{self.name} motor trajectory for requested fly/move is from "
+                f"{abs_start_pos}{egu} to "
+                f"{abs_end_pos}{egu} but motor limits are "
+                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+            )
+
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
         """Move to the beginning of a suitable run-up distance ready for a fly scan."""
@@ -126,22 +153,7 @@ class Motor(
         ramp_up_start_pos = value.ramp_up_start_pos(acceleration_time)
         ramp_down_end_pos = value.ramp_down_end_pos(acceleration_time)
 
-        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 >= 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} "
-            )
+        await self.check_motor_limit(ramp_up_start_pos, ramp_down_end_pos)
 
         # move to prepare position at maximum velocity
         await self.velocity.set(abs(max_speed))
@@ -199,6 +211,8 @@ class Motor(
                 msg = "Mover has zero velocity"
                 raise ValueError(msg) from error
 
+        await self.check_motor_limit(old_position, new_position)
+
         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

{ophyd_async-0.13.1/src/ophyd_async/epics/eiger → ophyd_async-0.13.3/src/ophyd_async/epics/odin}/_odin_io.py

@@ -90,11 +90,11 @@ class OdinWriter(DetectorWriter):
         self,
         path_provider: PathProvider,
         odin_driver: Odin,
-        eiger_bit_depth: SignalR[int],
+        detector_bit_depth: SignalR[int],
     ) -> None:
         self._drv = odin_driver
         self._path_provider = path_provider
-        self._eiger_bit_depth = Reference(eiger_bit_depth)
+        self._detector_bit_depth = Reference(detector_bit_depth)
         self._capture_status: AsyncStatus | None = None
         super().__init__()
 
@@ -103,7 +103,9 @@ class OdinWriter(DetectorWriter):
         self._exposures_per_event = exposures_per_event
 
         await asyncio.gather(
-            self._drv.data_type.set(f"UInt{await self._eiger_bit_depth().get_value()}"),
+            self._drv.data_type.set(
+                f"UInt{await self._detector_bit_depth().get_value()}"
+            ),
             self._drv.num_to_capture.set(0),
             self._drv.file_path.set(str(info.directory_path)),
             self._drv.file_name.set(info.filename),

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/src/ophyd_async/epics/pmac/__init__.py

@@ -1,8 +1,10 @@
 from ._pmac_io import PmacAxisAssignmentIO, PmacCoordIO, PmacIO, PmacTrajectoryIO
+from ._pmac_trajectory import PmacTrajectoryTriggerLogic
 
 __all__ = [
     "PmacAxisAssignmentIO",
     "PmacCoordIO",
     "PmacIO",
     "PmacTrajectoryIO",
+    "PmacTrajectoryTriggerLogic",
 ]

{ophyd_async-0.13.1 → ophyd_async-0.13.3}/src/ophyd_async/epics/pmac/_pmac_io.py

@@ -72,7 +72,7 @@ class PmacCoordIO(Device):
         self.cs_port = epics_signal_r(str, f"{prefix}Port")
         self.cs_axis_setpoint = DeviceVector(
             {
-                i + 1: epics_signal_rw(np.float64, f"{prefix}M{i + 1}:DirectDemand")
+                i + 1: epics_signal_rw(float, f"{prefix}M{i + 1}:DirectDemand")
                 for i in range(len(CS_LETTERS))
             }
         )
@@ -93,7 +93,7 @@ class PmacIO(Device):
 
         self.assignment = DeviceVector(
             {
-                i: PmacAxisAssignmentIO(motor_prefix)
+                i: PmacAxisAssignmentIO(motor_prefix + ":")
                 for i, motor_prefix in enumerate(motor_prefixes)
             }
         )

ophyd_async-0.13.3/src/ophyd_async/epics/pmac/_pmac_trajectory.py

@@ -0,0 +1,114 @@
+import asyncio
+
+import numpy as np
+from scanspec.core import Path
+from scanspec.specs import Spec
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    FlyerController,
+    set_and_wait_for_value,
+    wait_for_value,
+)
+from ophyd_async.epics.motor import Motor
+from ophyd_async.epics.pmac import PmacIO
+from ophyd_async.epics.pmac._pmac_io import CS_LETTERS
+from ophyd_async.epics.pmac._utils import (
+    _PmacMotorInfo,
+    _Trajectory,
+    calculate_ramp_position_and_duration,
+)
+
+
+class PmacTrajectoryTriggerLogic(FlyerController):
+    def __init__(self, pmac: PmacIO) -> None:
+        self.pmac = pmac
+        self.scantime: float | None = None
+
+    async def prepare(self, value: Spec[Motor]):
+        slice = Path(value.calculate()).consume()
+        motor_info = await _PmacMotorInfo.from_motors(self.pmac, slice.axes())
+        ramp_up_pos, ramp_up_time = calculate_ramp_position_and_duration(
+            slice, motor_info, True
+        )
+        ramp_down_pos, ramp_down_time = calculate_ramp_position_and_duration(
+            slice, motor_info, False
+        )
+        trajectory = _Trajectory.from_slice(slice, ramp_up_time, motor_info)
+        await asyncio.gather(
+            self._build_trajectory(
+                trajectory, motor_info, ramp_down_pos, ramp_down_time
+            ),
+            self._move_to_start(motor_info, ramp_up_pos),
+        )
+
+    async def kickoff(self):
+        if not self.scantime:
+            raise RuntimeError("Cannot kickoff. Must call prepare first.")
+        self.status = await self.pmac.trajectory.execute_profile.set(
+            True, timeout=self.scantime + 1
+        )
+
+    async def complete(self):
+        if not self.scantime:
+            raise RuntimeError("Cannot complete. Must call prepare first.")
+        await wait_for_value(
+            self.pmac.trajectory.execute_profile,
+            False,
+            timeout=self.scantime + DEFAULT_TIMEOUT,
+        )
+
+    async def stop(self):
+        await self.pmac.trajectory.abort_profile.set(True)
+
+    async def _build_trajectory(
+        self,
+        trajectory: _Trajectory,
+        motor_info: _PmacMotorInfo,
+        ramp_down_pos: dict[Motor, np.float64],
+        ramp_down_time: float,
+    ):
+        trajectory = trajectory.append_ramp_down(ramp_down_pos, ramp_down_time, 0)
+        self.scantime = np.sum(trajectory.durations)
+        use_axis = {axis + 1: False for axis in range(len(CS_LETTERS))}
+
+        for motor, number in motor_info.motor_cs_index.items():
+            use_axis[number + 1] = True
+            await self.pmac.trajectory.positions[number + 1].set(
+                trajectory.positions[motor]
+            )
+            await self.pmac.trajectory.velocities[number + 1].set(
+                trajectory.velocities[motor]
+            )
+
+        coros = [
+            self.pmac.trajectory.profile_cs_name.set(motor_info.cs_port),
+            self.pmac.trajectory.time_array.set(trajectory.durations),
+            self.pmac.trajectory.user_array.set(trajectory.user_programs),
+            self.pmac.trajectory.points_to_build.set(len(trajectory.durations)),
+            self.pmac.trajectory.calculate_velocities.set(False),
+        ] + [
+            self.pmac.trajectory.use_axis[number].set(use)
+            for number, use in use_axis.items()
+        ]
+        await asyncio.gather(*coros)
+        await self.pmac.trajectory.build_profile.set(True)
+
+    async def _move_to_start(
+        self, motor_info: _PmacMotorInfo, ramp_up_position: dict[Motor, np.float64]
+    ):
+        coord = self.pmac.coord[motor_info.cs_number]
+        coros = []
+        await coord.defer_moves.set(True)
+        for motor, position in ramp_up_position.items():
+            coros.append(
+                set_and_wait_for_value(
+                    coord.cs_axis_setpoint[motor_info.motor_cs_index[motor] + 1],
+                    position,
+                    set_timeout=10,
+                    wait_for_set_completion=False,
+                )
+            )
+        statuses = await asyncio.gather(*coros)
+        await coord.defer_moves.set(False)
+        await asyncio.gather(*statuses)