ophyd-async 0.12.3__py3-none-any.whl → 0.13.1__py3-none-any.whl

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,18 +1,15 @@
 import asyncio
 
-from ophyd_async.core import (
-    DetectorTrigger,
-    TriggerInfo,
-)
+from ophyd_async.core import DetectorTrigger, OnOff, TriggerInfo
 from ophyd_async.epics import adcore
 
-from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
+from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaTriggerSource
 
 TRIGGER_MODE = {
-    DetectorTrigger.INTERNAL: VimbaOnOff.OFF,
-    DetectorTrigger.CONSTANT_GATE: VimbaOnOff.ON,
-    DetectorTrigger.VARIABLE_GATE: VimbaOnOff.ON,
-    DetectorTrigger.EDGE_TRIGGER: VimbaOnOff.ON,
+    DetectorTrigger.INTERNAL: OnOff.OFF,
+    DetectorTrigger.CONSTANT_GATE: OnOff.ON,
+    DetectorTrigger.VARIABLE_GATE: OnOff.ON,
+    DetectorTrigger.EDGE_TRIGGER: OnOff.ON,
 }
 
 EXPOSE_OUT_MODE = {

ophyd_async/epics/advimba/_vimba_io.py

@@ -1,6 +1,6 @@
 from typing import Annotated as A
 
-from ophyd_async.core import SignalRW, StrictEnum
+from ophyd_async.core import OnOff, SignalRW, StrictEnum
 from ophyd_async.epics import adcore
 from ophyd_async.epics.core import PvSuffix
 
@@ -30,17 +30,10 @@ class VimbaTriggerSource(StrictEnum):
 class VimbaOverlap(StrictEnum):
     """Overlap modes for the Vimba detector."""
 
-    OFF = "Off"
+    OFF = OnOff.OFF.value
     PREV_FRAME = "PreviousFrame"
 
 
-class VimbaOnOff(StrictEnum):
-    """On/Off modes on the Vimba detector."""
-
-    ON = "On"
-    OFF = "Off"
-
-
 class VimbaExposeOutMode(StrictEnum):
     """Exposure control modes for Vimba detectors."""
 
@@ -55,6 +48,6 @@ class VimbaDriverIO(adcore.ADBaseIO):
         SignalRW[VimbaConvertFormat], PvSuffix("ConvertPixelFormat")
     ]
     trigger_source: A[SignalRW[VimbaTriggerSource], PvSuffix("TriggerSource")]
-    trigger_mode: A[SignalRW[VimbaOnOff], PvSuffix("TriggerMode")]
+    trigger_mode: A[SignalRW[OnOff], PvSuffix("TriggerMode")]
     trigger_overlap: A[SignalRW[VimbaOverlap], PvSuffix("TriggerOverlap")]
     exposure_mode: A[SignalRW[VimbaExposeOutMode], PvSuffix("ExposureMode")]

ophyd_async/epics/core/_aioca.py

@@ -1,4 +1,5 @@
 import logging
+import os
 import sys
 import typing
 from collections.abc import Mapping, Sequence
@@ -40,6 +41,10 @@ from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 logger = logging.getLogger("ophyd_async")
 
 
+def _all_updates() -> bool:
+    return os.environ.get("OPHYD_ASYNC_EPICS_CA_KEEP_ALL_UPDATES", "True") == "True"
+
+
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
     def get_limits(limit: str) -> LimitsRange | None:
         low = getattr(value, f"lower_{limit}_limit", nan)
@@ -250,12 +255,11 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         datatype: type[SignalDatatypeT] | None,
         read_pv: str = "",
         write_pv: str = "",
-        all_updates: bool = True,
     ):
         self.converter: CaConverter = DisconnectedCaConverter(float, dbr.DBR_DOUBLE)
         self.initial_values: dict[str, AugmentedValue] = {}
         self.subscription: Subscription | None = None
-        self._all_updates = all_updates
+        self._all_updates = _all_updates()
         super().__init__(datatype, read_pv, write_pv)
 
     def source(self, name: str, read: bool):

ophyd_async/epics/core/_p4p.py

@@ -22,7 +22,6 @@ from ophyd_async.core import (
     SignalDatatype,
     SignalDatatypeT,
     SignalMetadata,
-    StrictEnum,
     Table,
     get_enum_cls,
     get_unique,
@@ -82,7 +81,7 @@ def _metadata_from_value(datatype: type[SignalDatatype], value: Any) -> SignalMe
     if (limits := _limits_from_value(value)) and specifier[-1] in _number_specifiers:
         metadata["limits"] = limits
     # Get choices from display or value
-    if datatype is str or issubclass(datatype, StrictEnum):
+    if datatype is str or get_enum_cls(datatype) is not None:
         if hasattr(display_data, "choices"):
             metadata["choices"] = display_data.choices
         elif hasattr(value_data, "choices"):
@@ -327,7 +326,7 @@ def context() -> Context:
 async def pvget_with_timeout(pv: str, timeout: float) -> Any:
     try:
         return await asyncio.wait_for(context().get(pv), timeout=timeout)
-    except asyncio.TimeoutError as exc:
+    except TimeoutError as exc:
         logger.debug(f"signal pva://{pv} timed out", exc_info=True)
         raise NotConnected(f"pva://{pv}") from exc
 

ophyd_async/epics/core/_pvi_connector.py

@@ -6,13 +6,13 @@ from ophyd_async.core import (
     Device,
     DeviceConnector,
     DeviceFiller,
+    LazyMock,
     Signal,
     SignalR,
     SignalRW,
     SignalW,
     SignalX,
 )
-from ophyd_async.core._utils import LazyMock
 
 from ._epics_connector import fill_backend_with_prefix
 from ._signal import PvaSignalBackend, pvget_with_timeout

ophyd_async/epics/pmac/__init__.py

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

ophyd_async/epics/pmac/_pmac_io.py

@@ -69,6 +69,7 @@ class PmacCoordIO(Device):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.defer_moves = epics_signal_rw(bool, f"{prefix}DeferMoves")
+        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")

ophyd_async/epics/pmac/_utils.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+import numpy as np
+import numpy.typing as npt
+from scanspec.core import Slice
+
+from ophyd_async.core import error_if_none, gather_dict
+from ophyd_async.epics.motor import Motor
+
+from ._pmac_io import CS_LETTERS, PmacIO
+
+# PMAC durations are in milliseconds
+# We must convert from scanspec durations (seconds) to milliseconds
+# PMAC motion program multiples durations by 0.001
+# (see https://github.com/DiamondLightSource/pmac/blob/afe81f8bb9179c3a20eff351f30bc6cfd1539ad9/pmacApp/pmc/trajectory_scan_code_ppmac.pmc#L241)
+# Therefore, we must divide scanspec durations by 10e-6
+TICK_S = 0.000001
+
+
+@dataclass
+class _Trajectory:
+    positions: dict[Motor, np.ndarray]
+    velocities: dict[Motor, np.ndarray]
+    user_programs: npt.NDArray[np.int32]
+    durations: npt.NDArray[np.float64]
+
+    @classmethod
+    def from_slice(cls, slice: Slice[Motor], ramp_up_time: float) -> _Trajectory:
+        """Parse a trajectory with no gaps from a slice.
+
+        :param slice: Information about a series of scan frames along a number of axes
+        :param ramp_up_duration: Time required to ramp up to speed
+        :param ramp_down: Booleon representing if we ramp down or not
+        :returns Trajectory: Data class representing our parsed trajectory
+        :raises RuntimeError: Slice must have no gaps and a duration array
+        """
+        slice_duration = error_if_none(slice.duration, "Slice must have a duration")
+
+        # Check if any gaps other than initial gap.
+        if any(slice.gap[1:]):
+            raise RuntimeError(
+                f"Cannot parse trajectory with gaps. Slice has gaps: {slice.gap}"
+            )
+
+        scan_size = len(slice)
+        motors = slice.axes()
+
+        positions: dict[Motor, npt.NDArray[np.float64]] = {}
+        velocities: dict[Motor, npt.NDArray[np.float64]] = {}
+
+        # Initialise arrays
+        positions = {motor: np.empty(2 * scan_size + 1, float) for motor in motors}
+        velocities = {motor: np.empty(2 * scan_size + 1, float) for motor in motors}
+        durations: npt.NDArray[np.float64] = np.empty(2 * scan_size + 1, float)
+        user_programs: npt.NDArray[np.int32] = np.ones(2 * scan_size + 1, float)
+        user_programs[-1] = 8
+
+        # Ramp up time for start of collection window
+        durations[0] = int(ramp_up_time / TICK_S)
+        # Half the time per point
+        durations[1:] = np.repeat(slice_duration / (2 * TICK_S), 2)
+
+        # Fill profile assuming no gaps
+        # Excluding starting points, we begin at our next frame
+        half_durations = slice_duration / 2
+        for motor in motors:
+            # Set the first position to be lower bound, then
+            # alternate mid and upper as the upper and lower
+            # bounds of neighbouring points are the same as gap is false
+            positions[motor][0] = slice.lower[motor][0]
+            positions[motor][1::2] = slice.midpoints[motor]
+            positions[motor][2::2] = slice.upper[motor]
+            # For velocities we will need the relative distances
+            mid_to_upper_velocities = (
+                slice.upper[motor] - slice.midpoints[motor]
+            ) / half_durations
+            lower_to_mid_velocities = (
+                slice.midpoints[motor] - slice.lower[motor]
+            ) / half_durations
+            # First velocity is the lower -> mid of first point
+            velocities[motor][0] = lower_to_mid_velocities[0]
+            # For the midpoints, we take the average of the
+            # lower -> mid and mid-> upper velocities of the same point
+            velocities[motor][1::2] = (
+                lower_to_mid_velocities + mid_to_upper_velocities
+            ) / 2
+            # For the upper points, we need to take the average of the
+            # mid -> upper velocity of the previous point and
+            # lower -> mid velocity of the current point
+            velocities[motor][2:-1:2] = (
+                mid_to_upper_velocities[:-1] + lower_to_mid_velocities[1:]
+            ) / 2
+            # For the last velocity take the mid to upper velocity
+            velocities[motor][-1] = mid_to_upper_velocities[-1]
+
+        return cls(
+            positions=positions,
+            velocities=velocities,
+            user_programs=user_programs,
+            durations=durations,
+        )
+
+
+@dataclass
+class _PmacMotorInfo:
+    cs_port: str
+    cs_number: int
+    motor_cs_index: dict[Motor, int]
+    motor_acceleration_rate: dict[Motor, float]
+
+    @classmethod
+    async def from_motors(cls, pmac: PmacIO, motors: Sequence[Motor]) -> _PmacMotorInfo:
+        """Creates a _PmacMotorInfo instance based on a  controller and list of motors.
+
+        :param pmac: The PMAC device
+        :param motors: Sequence of motors involved in trajectory
+        :raises RuntimeError:
+            if motors do not share common CS port or CS number, or if
+            motors do not have unique CS index assignments
+        :returns:
+            _PmacMotorInfo instance with motor's common CS port and CS number, and
+            dictionaries of motor's to their unique CS index and accelerate rate
+
+        """
+        assignments = {
+            motor: pmac.assignment[pmac.motor_assignment_index[motor]]
+            for motor in motors
+        }
+
+        cs_ports, cs_numbers, cs_axes, velocities, accls = await asyncio.gather(
+            gather_dict(
+                {motor: assignments[motor].cs_port.get_value() for motor in motors}
+            ),
+            gather_dict(
+                {motor: assignments[motor].cs_number.get_value() for motor in motors}
+            ),
+            gather_dict(
+                {
+                    motor: assignments[motor].cs_axis_letter.get_value()
+                    for motor in motors
+                }
+            ),
+            gather_dict({motor: motor.max_velocity.get_value() for motor in motors}),
+            gather_dict(
+                {motor: motor.acceleration_time.get_value() for motor in motors}
+            ),
+        )
+
+        # check if the values in cs_port and cs_number are the same
+        cs_ports = set(cs_ports.values())
+
+        if len(cs_ports) != 1:
+            raise RuntimeError(
+                "Failed to fetch common CS port."
+                "Motors passed are assigned to multiple CS ports:"
+                f"{list(cs_ports)}"
+            )
+
+        cs_port = cs_ports.pop()
+
+        cs_numbers = set(cs_numbers.values())
+        if len(cs_numbers) != 1:
+            raise RuntimeError(
+                "Failed to fetch common CS number."
+                "Motors passed are assigned to multiple CS numbers:"
+                f"{list(cs_numbers)}"
+            )
+
+        cs_number = cs_numbers.pop()
+
+        motor_cs_index = {}
+        for motor in cs_axes:
+            try:
+                if not cs_axes[motor]:
+                    raise ValueError
+                motor_cs_index[motor] = CS_LETTERS.index(cs_axes[motor])
+            except ValueError as err:
+                raise ValueError(
+                    "Failed to get motor CS index. "
+                    f"Motor {motor.name} assigned to '{cs_axes[motor]}' "
+                    f"but must be assignmed to '{CS_LETTERS}"
+                ) from err
+            if len(set(motor_cs_index.values())) != len(motor_cs_index.items()):
+                raise RuntimeError(
+                    "Failed to fetch distinct CS Axes."
+                    "Motors passed are assigned to the same CS Axis"
+                    f"{list(motor_cs_index)}"
+                )
+
+        motor_acceleration_rate = {
+            motor: float(velocities[motor]) / float(accls[motor])
+            for motor in velocities
+        }
+
+        return _PmacMotorInfo(
+            cs_port, cs_number, motor_cs_index, motor_acceleration_rate
+        )
+
+
+def calculate_ramp_position_and_duration(
+    slice: Slice[Motor], motor_info: _PmacMotorInfo, is_up: bool
+) -> tuple[dict[Motor, float], float]:
+    if slice.duration is None:
+        raise ValueError("Slice must have a duration")
+
+    scan_axes = slice.axes()
+    idx = 0 if is_up else -1
+
+    velocities: dict[Motor, float] = {}
+    ramp_times: list[float] = []
+    for axis in scan_axes:
+        velocity = (slice.upper[axis][idx] - slice.lower[axis][idx]) / slice.duration[
+            idx
+        ]
+        velocities[axis] = velocity
+        ramp_times.append(abs(velocity) / motor_info.motor_acceleration_rate[axis])
+
+    max_ramp_time = max(ramp_times)
+
+    motor_to_ramp_position = {}
+    sign = -1 if is_up else 1
+    for axis, v in velocities.items():
+        ref_pos = slice.lower[axis][0] if is_up else slice.upper[axis][-1]
+        displacement = 0.5 * v * max_ramp_time
+        motor_to_ramp_position[axis] = ref_pos + sign * displacement
+
+    return (motor_to_ramp_position, max_ramp_time)

ophyd_async/epics/testing/_example_ioc.py

@@ -4,8 +4,7 @@ from typing import Annotated as A
 
 import numpy as np
 
-from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, Table
-from ophyd_async.core._utils import SubsetEnum
+from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, SubsetEnum, Table
 from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 from ._utils import TestingIOC, generate_random_pv_prefix

ophyd_async/plan_stubs/_nd_attributes.py

@@ -1,57 +1,31 @@
 from collections.abc import Sequence
-from xml.etree import ElementTree as ET
 
 import bluesky.plan_stubs as bps
 
-from ophyd_async.core import Device
 from ophyd_async.epics.adcore import (
+    AreaDetector,
     NDArrayBaseIO,
     NDAttributeDataType,
     NDAttributeParam,
     NDAttributePv,
     NDFileHDFIO,
+    ndattributes_to_xml,
 )
 
 
 def setup_ndattributes(
-    device: NDArrayBaseIO, ndattributes: Sequence[NDAttributePv | NDAttributeParam]
+    device: NDArrayBaseIO, ndattributes: Sequence[NDAttributeParam | NDAttributePv]
 ):
-    """Set up attributes on NdArray devices."""
-    root = ET.Element("Attributes")
-
-    for ndattribute in ndattributes:
-        if isinstance(ndattribute, NDAttributeParam):
-            ET.SubElement(
-                root,
-                "Attribute",
-                name=ndattribute.name,
-                type="PARAM",
-                source=ndattribute.param,
-                addr=str(ndattribute.addr),
-                datatype=ndattribute.datatype.value,
-                description=ndattribute.description,
-            )
-        elif isinstance(ndattribute, NDAttributePv):
-            ET.SubElement(
-                root,
-                "Attribute",
-                name=ndattribute.name,
-                type="EPICS_PV",
-                source=ndattribute.signal.source.split("ca://")[-1],
-                dbrtype=ndattribute.dbrtype.value,
-                description=ndattribute.description,
-            )
-        else:
-            raise ValueError(
-                f"Invalid type for ndattributes: {type(ndattribute)}. "
-                "Expected NDAttributePv or NDAttributeParam."
-            )
-    xml_text = ET.tostring(root, encoding="unicode")
-    yield from bps.abs_set(device.nd_attributes_file, xml_text, wait=True)
+    xml = ndattributes_to_xml(ndattributes)
+    yield from bps.abs_set(
+        device.nd_attributes_file,
+        xml,
+        wait=True,
+    )
 
 
-def setup_ndstats_sum(detector: Device):
-    """Set up nd stats for a detector."""
+def setup_ndstats_sum(detector: AreaDetector):
+    """Set up nd stats sum nd attribute for a detector."""
     hdf = getattr(detector, "fileio", None)
     if not isinstance(hdf, NDFileHDFIO):
         msg = (

ophyd_async/plan_stubs/_settings.py

@@ -13,10 +13,10 @@ from ophyd_async.core import (
     Settings,
     SettingsProvider,
     SignalRW,
+    Table,
     walk_config_signals,
     walk_rw_signals,
 )
-from ophyd_async.core._table import Table
 
 from ._utils import T
 from ._wait_for_awaitable import wait_for_awaitable

ophyd_async/tango/core/_tango_transport.py

@@ -212,7 +212,7 @@ class AttributeProxy(TangoProxy):
 
                 task = asyncio.create_task(_write())
                 await asyncio.wait_for(task, timeout)
-            except asyncio.TimeoutError as te:
+            except TimeoutError as te:
                 raise TimeoutError(f"{self._name} attr put failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(
@@ -451,7 +451,7 @@ class CommandProxy(TangoProxy):
                     timestamp=time.time(),
                     alarm_severity=0,
                 )
-            except asyncio.TimeoutError as te:
+            except TimeoutError as te:
                 raise TimeoutError(f"{self._name} command failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(

ophyd_async/testing/_assert.py

@@ -21,11 +21,11 @@ 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.
+def partial_reading(val: Any) -> Mapping[str, Any]:
+    """Helper function for building expected reading or configuration mapping.
 
-    :param val: Value to be wrapped in dict with "value" as the key.
-    :return: The dict that has wrapped the val with key "value".
+    :param val: Value to be wrapped in mapping with "value" as the key.
+    :return: The mapping that has wrapped the val with key "value".
     """
     return {"value": val}
 
@@ -100,7 +100,7 @@ def _assert_readings_approx_equal(
 
 async def assert_configuration(
     configurable: AsyncConfigurable,
-    expected_configuration: dict[str, dict[str, Any]],
+    expected_configuration: Mapping[str, Mapping[str, Any]],
     full_match: bool = True,
 ) -> None:
     """Assert that a configurable Device has the given configuration.
@@ -108,7 +108,7 @@ async def assert_configuration(
     :param configurable:
         Device with an async ``read_configuration()`` method to get the
         configuration from.
-    :param configuration: The expected configuration from the configurable.
+    :param expected_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

ophyd_async/testing/_one_of_everything.py

@@ -6,6 +6,7 @@ import numpy as np
 from ophyd_async.core import (
     Array1D,
     Device,
+    DeviceVector,
     DTypeScalar_co,
     SignalRW,
     StandardReadable,
@@ -15,7 +16,6 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.core._device import DeviceVector
 
 
 class ExampleEnum(StrictEnum):

{ophyd_async-0.12.3.dist-info → ophyd_async-0.13.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.12.3
+Version: 0.13.1
 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
@@ -35,10 +35,10 @@ License: BSD 3-Clause License
 Project-URL: GitHub, https://github.com/bluesky/ophyd-async
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -49,6 +49,7 @@ Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Requires-Dist: stamina>=23.1.0
+Requires-Dist: scanspec>=1.0a1
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
@@ -56,7 +57,7 @@ Requires-Dist: aioca>=2.0a4; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p>=4.2.0; extra == "pva"
 Provides-Extra: tango
-Requires-Dist: pytango==10.0.0; extra == "tango"
+Requires-Dist: pytango==10.0.2; extra == "tango"
 Provides-Extra: demo
 Requires-Dist: ipython; extra == "demo"
 Requires-Dist: matplotlib; extra == "demo"