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

ophyd_async/fastcs/eiger/_eiger.py

@@ -4,7 +4,7 @@ from ophyd_async.core import (
     StandardDetector,
     TriggerInfo,
 )
-from ophyd_async.epics.eiger import Odin, OdinWriter
+from ophyd_async.epics.odin import Odin, OdinWriter
 
 from ._eiger_controller import EigerController
 from ._eiger_io import EigerDriverIO

ophyd_async/fastcs/jungfrau/__init__.py

@@ -0,0 +1,29 @@
+from ._controller import JungfrauController
+from ._jungfrau import Jungfrau
+from ._signals import (
+    AcquisitionType,
+    DetectorStatus,
+    GainMode,
+    JungfrauDriverIO,
+    JungfrauTriggerMode,
+    PedestalMode,
+)
+from ._utils import (
+    create_jungfrau_external_triggering_info,
+    create_jungfrau_internal_triggering_info,
+    create_jungfrau_pedestal_triggering_info,
+)
+
+__all__ = [
+    "Jungfrau",
+    "DetectorStatus",
+    "create_jungfrau_external_triggering_info",
+    "create_jungfrau_internal_triggering_info",
+    "create_jungfrau_pedestal_triggering_info",
+    "JungfrauController",
+    "JungfrauDriverIO",
+    "JungfrauTriggerMode",
+    "AcquisitionType",
+    "GainMode",
+    "PedestalMode",
+]

ophyd_async/fastcs/jungfrau/_controller.py

@@ -0,0 +1,139 @@
+import asyncio
+import logging
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    DetectorController,
+    DetectorTrigger,
+    TriggerInfo,
+    wait_for_value,
+)
+
+from ._signals import (
+    JUNGFRAU_TRIGGER_MODE_MAP,
+    AcquisitionType,
+    DetectorStatus,
+    JungfrauDriverIO,
+    PedestalMode,
+)
+
+# Deadtime is dependant on a wide combination of settings and on trigger mode
+# but this is safe upper-limit
+JUNGFRAU_DEADTIME_S = 2e-5
+
+logger = logging.getLogger("ophyd_async")
+
+
+class JungfrauController(DetectorController):
+    def __init__(self, driver: JungfrauDriverIO):
+        self._driver = driver
+
+    def get_deadtime(self, exposure: float | None = None) -> float:
+        return JUNGFRAU_DEADTIME_S
+
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        # ValueErrors and warnings in this function come from the jungfrau operation
+        # docs: https://rtd.xfel.eu/docs/jungfrau-detector-documentation/en/latest/operation.html
+
+        # Deadtime here is really used as "time between frames"
+
+        acquisition_type = await self._driver.acquisition_type.get_value()
+        logger.info(f"Preparing Jungfrau in {acquisition_type} mode.")
+
+        if trigger_info.trigger not in (
+            DetectorTrigger.INTERNAL,
+            DetectorTrigger.EDGE_TRIGGER,
+        ):
+            raise ValueError(
+                "The trigger method can only be called with internal or edge triggering"
+            )
+        if (
+            acquisition_type == AcquisitionType.PEDESTAL
+            and trigger_info.trigger != DetectorTrigger.INTERNAL
+        ):
+            raise ValueError(
+                "Jungfrau must be triggered internally while in pedestal mode."
+            )
+
+        if not isinstance(trigger_info.number_of_events, int):
+            raise TypeError("Number of events must be an integer")
+
+        if acquisition_type != AcquisitionType.PEDESTAL:
+            if (
+                trigger_info.trigger == DetectorTrigger.INTERNAL
+                and trigger_info.number_of_events != 1
+            ):
+                raise ValueError(
+                    "Number of events must be set to 1 in internal trigger mode during "
+                    "standard acquisitions."
+                )
+
+            if (
+                trigger_info.trigger == DetectorTrigger.EDGE_TRIGGER
+                and trigger_info.exposures_per_event != 1
+            ):
+                raise ValueError(
+                    "Exposures per event must be set to 1 in edge trigger mode "
+                    "during standard acquisitions."
+                )
+
+        if not trigger_info.livetime:
+            raise ValueError("Must set TriggerInfo.livetime")
+
+        if trigger_info.livetime < 2e-6:
+            logger.warning("Exposure time shorter than 2μs is not recommended")
+
+        period_between_frames = trigger_info.livetime + trigger_info.deadtime
+
+        if period_between_frames < self.get_deadtime():
+            raise ValueError(
+                f"Period between frames (exposure time - deadtime) = "
+                f"{period_between_frames}s cannot be lower than minimum detector "
+                f"deadtime {self.get_deadtime()}"
+            )
+
+        coros = [
+            self._driver.trigger_mode.set(
+                JUNGFRAU_TRIGGER_MODE_MAP[trigger_info.trigger]
+            ),
+            self._driver.period_between_frames.set(period_between_frames),
+            self._driver.exposure_time.set(trigger_info.livetime),
+        ]
+
+        match acquisition_type:
+            case AcquisitionType.STANDARD:
+                frames_signal = (
+                    trigger_info.exposures_per_event
+                    if trigger_info.trigger is DetectorTrigger.INTERNAL
+                    else trigger_info.number_of_events
+                )
+                coros.extend(
+                    [
+                        self._driver.frames_per_acq.set(frames_signal),
+                    ]
+                )
+            case AcquisitionType.PEDESTAL:
+                coros.extend(
+                    [
+                        self._driver.pedestal_mode_frames.set(
+                            trigger_info.exposures_per_event
+                        ),
+                        self._driver.pedestal_mode_loops.set(
+                            trigger_info.number_of_events
+                        ),
+                        self._driver.pedestal_mode_state.set(PedestalMode.ON),
+                    ]
+                )
+
+        await asyncio.gather(*coros)
+
+    async def arm(self):
+        await self._driver.acquisition_start.trigger()
+
+    async def wait_for_idle(self):
+        await wait_for_value(
+            self._driver.detector_status, DetectorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+        )
+
+    async def disarm(self):
+        await self._driver.acquisition_stop.trigger()

ophyd_async/fastcs/jungfrau/_jungfrau.py

@@ -0,0 +1,30 @@
+from ophyd_async.core import (
+    PathProvider,
+    StandardDetector,
+)
+from ophyd_async.epics.odin import Odin, OdinWriter
+from ophyd_async.fastcs.jungfrau._controller import JungfrauController
+from ophyd_async.fastcs.jungfrau._signals import JungfrauDriverIO
+
+
+class Jungfrau(StandardDetector[JungfrauController, OdinWriter]):
+    """Ophyd-async implementation of a Jungfrau Detector."""
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix: str,
+        hdf_suffix: str,
+        odin_nodes: int,
+        name="",
+    ):
+        self.drv = JungfrauDriverIO(prefix + drv_suffix)
+        self.odin = Odin(prefix + hdf_suffix, nodes=odin_nodes)
+        writer = OdinWriter(
+            path_provider,
+            self.odin,
+            self.drv.bit_depth,
+        )
+        controller = JungfrauController(self.drv)
+        super().__init__(controller, writer, name=name)

ophyd_async/fastcs/jungfrau/_signals.py

@@ -0,0 +1,94 @@
+from pydantic import NonNegativeInt
+
+from ophyd_async.core import (
+    DetectorTrigger,
+    Device,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StrictEnum,
+    soft_signal_rw,
+)
+from ophyd_async.fastcs.core import fastcs_connector
+
+
+class JungfrauTriggerMode(StrictEnum):
+    INTERNAL = "Internal"
+
+    # Detector waits for external trigger to start frame series, but still
+    # controls exposure time and frame period internally
+    EXTERNAL = "External"
+
+
+class DetectorStatus(StrictEnum):
+    IDLE = "Idle"
+    ERROR = "Error"
+    WAITING = "Waiting"
+    RUN_FINISHED = "RunFinished"
+    TRANSMITTING = "Transmitting"
+    RUNNING = "Running"
+    STOPPED = "Stopped"
+
+
+class GainMode(StrictEnum):
+    DYNAMIC = "Dynamic"
+    FORCE_SWITCH_G1 = "ForceSwitchG1"
+    FORCE_SWITCH_G2 = "ForceSwitchG2"
+    FIX_G1 = "FixG1"
+    FIX_G2 = "FixG2"
+
+    # Use with caution - this may damage the detector
+    FIX_G0 = "FixG0"
+
+
+class PedestalMode(StrictEnum):
+    ON = "On"
+    OFF = "Off"
+
+
+class AcquisitionType(StrictEnum):
+    STANDARD = "Standard"
+    PEDESTAL = "Pedestal"
+
+
+JUNGFRAU_TRIGGER_MODE_MAP = {
+    DetectorTrigger.EDGE_TRIGGER: JungfrauTriggerMode.EXTERNAL,
+    DetectorTrigger.INTERNAL: JungfrauTriggerMode.INTERNAL,
+}
+
+
+class JungfrauDriverIO(Device):
+    """Contains signals for handling IO on the Jungfrau detector."""
+
+    exposure_time: SignalRW[float]  # in s
+
+    # Includes deadtime
+    period_between_frames: SignalRW[float]  # in s
+
+    # Sets the delay for the beginning of the exposure time after
+    # trigger input
+    delay_after_trigger: SignalRW[float]  # in s
+
+    # In internal trigger mode, this is frames per trigger. In external trigger mode,
+    # this is frames per overall acquisition. In pedestal mode, this signal is not set.
+    frames_per_acq: SignalRW[NonNegativeInt]
+
+    pedestal_mode_state: SignalRW[PedestalMode]
+    pedestal_mode_frames: SignalRW[NonNegativeInt]
+    pedestal_mode_loops: SignalRW[NonNegativeInt]
+
+    gain_mode: SignalRW[GainMode]
+
+    acquisition_start: SignalX
+
+    acquisition_stop: SignalX
+    bit_depth: SignalR[int]
+    trigger_mode: SignalRW[JungfrauTriggerMode]
+    detector_status: SignalR[DetectorStatus]
+
+    def __init__(self, uri: str, name: str = ""):
+        # Determines how the TriggerInfo gets mapped to the Jungfrau during prepare
+        self.acquisition_type = soft_signal_rw(
+            AcquisitionType, AcquisitionType.STANDARD
+        )
+        super().__init__(name=name, connector=fastcs_connector(self, uri))

ophyd_async/fastcs/jungfrau/_utils.py

@@ -0,0 +1,79 @@
+from pydantic import PositiveInt
+
+from ophyd_async.core import DetectorTrigger, TriggerInfo
+
+
+def create_jungfrau_external_triggering_info(
+    total_triggers: PositiveInt,
+    exposure_time_s: float,
+) -> TriggerInfo:
+    """Create safe Jungfrau TriggerInfo for external triggering.
+
+    Uses parameters which more closely-align with Jungfrau terminology
+    to create TriggerInfo. This device currently only supports one frame per trigger
+    when being externally triggered, but support for this can be added if needed
+
+    Args:
+        total_triggers: Total external triggers expected before ending acquisition.
+        exposure_time_s: How long to expose the detector for each of its frames.
+
+    Returns:
+        `TriggerInfo`
+    """
+    return TriggerInfo(
+        number_of_events=total_triggers,
+        trigger=DetectorTrigger.EDGE_TRIGGER,
+        livetime=exposure_time_s,
+    )
+
+
+def create_jungfrau_internal_triggering_info(
+    number_of_frames: PositiveInt, exposure_time_s: float
+) -> TriggerInfo:
+    """Create safe Jungfrau TriggerInfo for internal triggering.
+
+    Uses parameters which more closely-align with Jungfrau terminology
+    to create TriggerInfo.
+
+    Args:
+        number_of_frames: Total frames taken after starting acquisition.
+        exposure_time_s: How long to expose the detector for each of its frames.
+
+    Returns:
+        `TriggerInfo`
+    """
+    return TriggerInfo(
+        number_of_events=1,
+        trigger=DetectorTrigger.INTERNAL,
+        livetime=exposure_time_s,
+        exposures_per_event=number_of_frames,
+    )
+
+
+def create_jungfrau_pedestal_triggering_info(
+    exposure_time_s: float,
+    pedestal_frames: PositiveInt,
+    pedestal_loops: PositiveInt,
+):
+    """Create safe Jungfrau TriggerInfo for pedestal triggering.
+
+    Uses parameters which more closely-align with Jungfrau terminology
+    to create TriggerInfo.
+
+    NOTE: To trigger the jungfrau in pedestal mode, you must first set the
+    jungfrau acquisition_type signal to AcquisitionType.PEDESTAL!
+
+    Args:
+        exposure_time_s: How long to expose the detector for each of its frames.
+        pedestal_frames: Number of frames taken once triggering begins
+        pedestal_loops: Number of repeats of the pedestal scan before detector disarms.
+
+    Returns:
+        `TriggerInfo`
+    """
+    return TriggerInfo(
+        number_of_events=pedestal_loops,
+        exposures_per_event=pedestal_frames,
+        trigger=DetectorTrigger.INTERNAL,
+        livetime=exposure_time_s,
+    )

ophyd_async/sim/_motor.py

@@ -23,11 +23,19 @@ from ophyd_async.core import StandardReadableFormat as Format
 class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float]):
     """For usage when simulating a motor."""
 
-    def __init__(self, name="", instant=True) -> None:
+    def __init__(
+        self,
+        name: str = "",
+        instant: bool = True,
+        initial_value: float = 0.0,
+        units: str = "mm",
+    ) -> None:
         """Simulate a motor, with optional velocity.
 
         :param name: name of device
         :param instant: whether to move instantly or calculate move time using velocity
+        :param initial_value: initial position of the motor
+        :param units: units of the motor position
         """
         # Define some signals
         with self.add_children_as_readables(Format.HINTED_SIGNAL):
@@ -37,8 +45,8 @@ class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float
         with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.velocity = soft_signal_rw(float, 0 if instant else 1.0)
             self.acceleration_time = soft_signal_rw(float, 0.5)
-            self.units = soft_signal_rw(str, "mm")
-        self.user_setpoint = soft_signal_rw(float, 0)
+            self.units = soft_signal_rw(str, units)
+        self.user_setpoint = soft_signal_rw(float, initial_value)
 
         # Whether set() should complete successfully or not
         self._set_success = True

ophyd_async/sim/_point_detector.py

@@ -41,9 +41,12 @@ class SimPointDetector(StandardReadable):
     """Simalutes a point detector with multiple channels."""
 
     def __init__(
-        self, generator: PatternGenerator, num_channels: int = 3, name: str = ""
+        self,
+        pattern_generator: PatternGenerator | None,
+        num_channels: int = 3,
+        name: str = "",
     ) -> None:
-        self._generator = generator
+        self.pattern_generator = pattern_generator or PatternGenerator()
         self.acquire_time = soft_signal_rw(float, 0.1)
         self.acquiring, self._set_acquiring = soft_signal_r_and_setter(bool)
         self._value_signals = dict(
@@ -75,7 +78,7 @@ class SimPointDetector(StandardReadable):
             # Update the channel value
             for i, channel in self.channel.items():
                 high_energy = modes[channel] == EnergyMode.HIGH
-                point = self._generator.generate_point(i, high_energy)
+                point = self.pattern_generator.generate_point(i, high_energy)
                 setter = self._value_signals[channel.value]
                 setter(int(point * 10000 * update_time))
 

ophyd_async/sim/_stage.py

@@ -8,12 +8,23 @@ class SimStage(StandardReadable):
     """A simulated sample stage with X and Y movables."""
 
     def __init__(self, pattern_generator: PatternGenerator, name="") -> None:
+        self.pattern_generator = pattern_generator
         # Define some child Devices
         with self.add_children_as_readables():
             self.x = SimMotor(instant=False)
             self.y = SimMotor(instant=False)
-        # Tell the pattern generator about the motor positions
-        self.x.user_readback.subscribe_value(pattern_generator.set_x)
-        self.y.user_readback.subscribe_value(pattern_generator.set_y)
         # Set name of device and child devices
         super().__init__(name=name)
+
+    def stage(self):
+        """Stage the motors and report the position to the pattern generator."""
+        # Tell the pattern generator about the motor positions
+        self.x.user_readback.subscribe_value(self.pattern_generator.set_x)
+        self.y.user_readback.subscribe_value(self.pattern_generator.set_y)
+        return super().stage()
+
+    def unstage(self):
+        """Unstage the motors and remove the position subscription."""
+        self.x.user_readback.clear_sub(self.pattern_generator.set_x)
+        self.y.user_readback.clear_sub(self.pattern_generator.set_y)
+        return super().unstage()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.1
+Version: 0.13.2
 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
@@ -50,6 +50,7 @@ Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Requires-Dist: stamina>=23.1.0
 Requires-Dist: scanspec>=1.0a1
+Requires-Dist: velocity-profile
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca

{ophyd_async-0.13.1.dist-info → ophyd_async-0.13.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
 ophyd_async/__init__.py,sha256=dcAA3qsj1nNIMe5l-v2tlduZ_ypwBmyuHe45Lsq4k4w,206
 ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
 ophyd_async/_docs_parser.py,sha256=gPYrigfSbYCF7QoSf2UvE-cpQu4snSssl7ZWN-kKDzI,352
-ophyd_async/_version.py,sha256=RBWKvLuPH5uJN_RJXTOaV5SvvBYz1PUZvU4D8m3gAvo,706
+ophyd_async/_version.py,sha256=XZecU3ohLLhnQNT8_JmdvW2idqqOh08RIDcm2qzc5t8,706
 ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/core/__init__.py,sha256=yRb_6ufTXFtf3fagShfmSDfiMduIhvNPgQyM-7GGwas,4929
+ophyd_async/core/__init__.py,sha256=KBj8v-Fxh8V1QKJYR0xAjoziqo1vjyblx45H7Jrikd0,4979
 ophyd_async/core/_derived_signal.py,sha256=TuZza_j3J1Bw4QSqBYB9Ta2FyQP5BycO3nSHVtJ890Q,13015
 ophyd_async/core/_derived_signal_backend.py,sha256=PYyyont_nUR9LBC9eqVwueHCMwLJfQ_F7R_14sivBTU,12510
 ophyd_async/core/_detector.py,sha256=bPTQYLTjbxs7-wjV8szAZ0TQI20fV12vkq1OaA5L_z8,14938
@@ -18,7 +18,7 @@ ophyd_async/core/_protocol.py,sha256=wQ_snxhTprHqEjQb1HgFwBljwolMY6A8C3xgV1PXwdU
 ophyd_async/core/_providers.py,sha256=WBht3QCgvGc0stNcwH6z4Zr6hAz3e01-88NjsYI2w6I,9740
 ophyd_async/core/_readable.py,sha256=iBo1YwA5bsAbzLbznvmSnzKDWUuGkLh850Br3BXsgeU,11707
 ophyd_async/core/_settings.py,sha256=_ZccbXKP7j5rG6-bMKk7aaLr8hChdRDAPY_YSR71XXM,4213
-ophyd_async/core/_signal.py,sha256=uBeiLblabI0QUzEOrjtqS6pNnYkzAsadtm_KX628Kt4,28145
+ophyd_async/core/_signal.py,sha256=ghgxtfUG9vkwgvuu6qXa_ECux5-3j9WwxB5mN5G6jqU,28421
 ophyd_async/core/_signal_backend.py,sha256=PvwTbbSVEGqM-2s5BNRrKGwM_MiYL71qMxYAgyZ7wRM,6930
 ophyd_async/core/_soft_signal_backend.py,sha256=NJUuyaCKtBZjggt8WKi7_lKQRHasToxviuQvl5xbhLU,6222
 ophyd_async/core/_status.py,sha256=h4TtWFM7wFtpxxyAYYSITgcVzArYZdYBHbya6qIX5t0,6553
@@ -26,7 +26,7 @@ ophyd_async/core/_table.py,sha256=ai-_W-_WMZcy9f69BDYRv9vjVl-AVeOPN_uHYoGCSsc,69
 ophyd_async/core/_utils.py,sha256=-iKbqsvVR7P29E6VpOgI5WfDwGBRdud_gvExIoUVlG4,12495
 ophyd_async/core/_yaml_settings.py,sha256=Qojhku9l5kPSkTnEylCRWTe0gpw6S_XP5av5dPpqFgQ,2089
 ophyd_async/epics/__init__.py,sha256=ou4yEaH9VZHz70e8oM614-arLMQvUfQyXhRJsnEpWn8,60
-ophyd_async/epics/motor.py,sha256=UFolYxuaePnWNJNOFzgI-He4kBTHhJqaTywtqFFSmsk,8475
+ophyd_async/epics/motor.py,sha256=oRAAW-KWbMnAxHdOMKMt1ZrzgD5KzHX9iRwd0TYZXwI,8747
 ophyd_async/epics/signal.py,sha256=0A-supp9ajr63O6aD7F9oG0-Q26YmRjk-ZGh57-jo1Y,239
 ophyd_async/epics/adandor/__init__.py,sha256=dlitllrAdhvh16PAcVMUSSEytTDNMu6_HuYk8KD1EoY,343
 ophyd_async/epics/adandor/_andor.py,sha256=TijGjNVxuH-P0X7UACPt9eLLQ449DwMyVhbn1kV7Le8,1245
@@ -64,7 +64,7 @@ ophyd_async/epics/advimba/_vimba_controller.py,sha256=KSbP4LHqYkCDplpmBk7hdf0Yz9
 ophyd_async/epics/advimba/_vimba_io.py,sha256=E3XlCKLQbGOWho0dQPeD4xeEl5pZGINyYstGD43qNrM,1492
 ophyd_async/epics/core/__init__.py,sha256=q73i4aJ_0HApVNmf3eAw-q30XuazAyZW2MW5TXk-pOY,648
 ophyd_async/epics/core/_aioca.py,sha256=38aW5dd3MzwhoweNMjkOfnfZHI2JZFateO0YABGVSfQ,13230
-ophyd_async/epics/core/_epics_connector.py,sha256=S4z_wbj-aogVcjqCyUgjhcq5Y4gDC7y6wXbsSz2nODY,1918
+ophyd_async/epics/core/_epics_connector.py,sha256=KXQ1WVpNrgQ30KiiXTYRwfoHdaU5oWv1jVZAvx3tGig,2557
 ophyd_async/epics/core/_epics_device.py,sha256=wGdR24I7GSPh3HmM7jsWKZhBZgt4IyLrCn4Ut7Wx_xo,510
 ophyd_async/epics/core/_p4p.py,sha256=Q6o4rlyrg2VXlqi1uHkGbnYc1gZ8YX5ZaJDcL0eAr_8,16385
 ophyd_async/epics/core/_pvi_connector.py,sha256=SfKkZqGCRvJJtQpJQzmfuLJQqOge0wBsMeuTSQ-KPjs,5553
@@ -80,11 +80,12 @@ ophyd_async/epics/demo/_stage.py,sha256=KPnwr5EX8f_0xxkNWT-70a0AqB0D9DoiTbxMmy0i
 ophyd_async/epics/demo/motor.db,sha256=3xb6WTXo4crrvk-M8Y16G9pUidp27vD5vIKKBpLTUlk,1017
 ophyd_async/epics/demo/point_detector.db,sha256=8kBa3XKpmfXCxetT4tq5_RFXa_XqS1Z2ZNzsa2AtLds,1366
 ophyd_async/epics/demo/point_detector_channel.db,sha256=FZ9H6HjqplhcF2jgimv_dT1nn-CBlfjs7Y--iCfHp5Y,632
-ophyd_async/epics/eiger/__init__.py,sha256=7kRqVzwoD8PVtp7Nj9iQWlgbLeoWE_8oiq-B0kixwTE,93
-ophyd_async/epics/eiger/_odin_io.py,sha256=JTnsADwNszWJoXpFmdcrZrCDc_RshGlM3Bg_aeUdrUg,6491
-ophyd_async/epics/pmac/__init__.py,sha256=fQAFnVtzEiPlzXI5XgB62HyburMbUKDfOgkIO_JBPYc,182
-ophyd_async/epics/pmac/_pmac_io.py,sha256=_lTUdNHTWOwPitAxXottyLrmiwhf36WfTbrdneqeg34,4022
-ophyd_async/epics/pmac/_utils.py,sha256=6bb_yKNcmWSfuaYunRv5GcA8ML4jEUsf1jkXko_LSEo,8888
+ophyd_async/epics/odin/__init__.py,sha256=7kRqVzwoD8PVtp7Nj9iQWlgbLeoWE_8oiq-B0kixwTE,93
+ophyd_async/epics/odin/_odin_io.py,sha256=YDBrS15PnEKe5SHmz397Emh--lZSQEnbR3G7p8pbShY,6533
+ophyd_async/epics/pmac/__init__.py,sha256=GqJTiJudqE9pu050ZNED09F9tKRfazn0wBsojsMH2gg,273
+ophyd_async/epics/pmac/_pmac_io.py,sha256=Nnenk7HHyzzqe0jIg2FAtxFohFnr_ByDZ0IAEI4_Ls4,4023
+ophyd_async/epics/pmac/_pmac_trajectory.py,sha256=Q9Ry2xzL7FqszehhfBfhu-5-fFyPcJiD2Iu86c9pQ7w,4167
+ophyd_async/epics/pmac/_utils.py,sha256=ahN5zMfO3-gNV7H1fQ5wsDeGUL9IpMQa2g27rhVf0uU,34326
 ophyd_async/epics/testing/__init__.py,sha256=aTIv4D2DYrpnGco5RQF8QuLG1SfFkIlTyM2uYEKXltA,522
 ophyd_async/epics/testing/_example_ioc.py,sha256=zb4ZEUzuB2MrSw5ETPLIiHhf-2BRU1Bdxco6Kh4iI1I,3880
 ophyd_async/epics/testing/_utils.py,sha256=9gxpwaWX0HGtacu1LTupcw7viXN8G78RmuNciU_-cjs,1702
@@ -93,9 +94,14 @@ ophyd_async/epics/testing/test_records_pva.db,sha256=HJAJSvLtPWG5B5dKv8OZ0_hPJxR
 ophyd_async/fastcs/__init__.py,sha256=qlIM9-pjJ8yWfnzTM9-T9cw7zQLKjeeNROQTni5Dr6M,80
 ophyd_async/fastcs/core.py,sha256=pL_srtTrfuoBHUjDFpxES92owFq9M4Jve0Skk1oeuFA,517
 ophyd_async/fastcs/eiger/__init__.py,sha256=RxwOFjERKy5tUD_IDGCGuMh716FaZgCq7R9elPixBwo,312
-ophyd_async/fastcs/eiger/_eiger.py,sha256=X6KczJ9JMdZUEnlt2ozUhlL8Tk1MfzgmPIpVFXdisNw,1104
+ophyd_async/fastcs/eiger/_eiger.py,sha256=jo3K5dM3Co_RDYIyO6poCVDqp2g_1z4MqnYftwnMhUk,1103
 ophyd_async/fastcs/eiger/_eiger_controller.py,sha256=Cucj-1M-1CaxSJxHZmHs3f_OXwtTIspcqUFhRNGzn_E,2361
 ophyd_async/fastcs/eiger/_eiger_io.py,sha256=yNozTKX4CMoqIaFvyKJEs5RXXGJ4VITP_T4TIFHWRmc,1242
+ophyd_async/fastcs/jungfrau/__init__.py,sha256=6BV6czpOWmDuTAKR-47tRFdM3Q5dQenHnPPAYiWOFk0,717
+ophyd_async/fastcs/jungfrau/_controller.py,sha256=OiPCVwYtY_0bx5His9qVsRHzG8-Rjg087B6c71gO5Q8,4836
+ophyd_async/fastcs/jungfrau/_jungfrau.py,sha256=KAHCmRHMyzIh-r2JXVJcQOGLkCOOdW5Mao_KChITO2s,929
+ophyd_async/fastcs/jungfrau/_signals.py,sha256=8seZCkKTb-xJL0IdB2el8VTEbWNaCvZIhpP0609GpxI,2500
+ophyd_async/fastcs/jungfrau/_utils.py,sha256=-NeIlUW7Mx9llUC6FZORc6e-IAAOL9lwzzl07wc8lTc,2509
 ophyd_async/fastcs/odin/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
 ophyd_async/fastcs/panda/__init__.py,sha256=ugrScVm4HPQFc-d1kTAfZ5UUzW9T3SPgTi0OD2s8ZH0,1003
 ophyd_async/fastcs/panda/_block.py,sha256=SM7NaWCRwLz2Pl4wgjZMrDgx3ZLdGPTw6nU0bA-65yA,2394
@@ -119,10 +125,10 @@ ophyd_async/sim/_blob_detector_controller.py,sha256=y1aSNQJUPnsT2qnj2sk254Mp18an
 ophyd_async/sim/_blob_detector_writer.py,sha256=_Pd0OaP4_mZfwxtUF35v7hsktLP_wYljR4nylr5CzJo,3346
 ophyd_async/sim/_mirror_horizontal.py,sha256=Jsqa8Snjy1jQDboZtAQFJjGor5uKk8FBC7OCe-GoZDw,1478
 ophyd_async/sim/_mirror_vertical.py,sha256=HUD44mYT0jQ0GKiQKxD7k_7y6o6OdE6TztgdPUJIK_g,2085
-ophyd_async/sim/_motor.py,sha256=7s2jBNwWm4CI6I6l_LEpe7z61QdWy82JdZBKSFOnYe4,8994
+ophyd_async/sim/_motor.py,sha256=EUykjGfQgBnf0Pmr66XeDlhz8DU0eAIXUvIgbtJccoA,9226
 ophyd_async/sim/_pattern_generator.py,sha256=kuxvyX2gIxrywhQRhaO1g8YluBT7LBkE20IsurZS-6o,3734
-ophyd_async/sim/_point_detector.py,sha256=nXgL_1aJZciNBw8Zr2wMYaMbzzAEKXV3yV8FQz2nS_4,2940
-ophyd_async/sim/_stage.py,sha256=qaeyZbUVL1v2pTHJiZxq-y6BKpA1l_DAKyzAQppQx70,772
+ophyd_async/sim/_point_detector.py,sha256=wMG_ncvm99WMCPihlFyuMEf3UknAxCpB1hpk3uKiENE,3024
+ophyd_async/sim/_stage.py,sha256=fOR5HGWfqWw47-0HrMmQ5rait_qPVNneF329wCx8KKY,1233
 ophyd_async/tango/__init__.py,sha256=g9xzjlzPpUAP12YI-kYwfAoLSYPAQdL1S11R2c-cius,60
 ophyd_async/tango/core/__init__.py,sha256=IMvQ7MWcTof99h_pr483KWKvQV2-h7zo_iRpLA2PUYQ,1108
 ophyd_async/tango/core/_base_device.py,sha256=e9oqSL-fDOj8r9nUUFZkbibhRGbI6HYtlnZjK5B_2fE,5033
@@ -147,8 +153,8 @@ ophyd_async/testing/_one_of_everything.py,sha256=U9ui7B-iNHDM3H3hIWUuaCb8Gc2eLlU
 ophyd_async/testing/_single_derived.py,sha256=5-HOTzgePcZ354NK_ssVpyIbJoJmKyjVQCxSwQXUC-4,2730
 ophyd_async/testing/_utils.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
 ophyd_async/testing/_wait_for_pending.py,sha256=YZAR48n-CW0GsPey3zFRzMJ4byDAr3HvMIoawjmTrHw,732
-ophyd_async-0.13.1.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.13.1.dist-info/METADATA,sha256=C7N-G9XhmTuI2S1P6V1efiRZTInRDDaG9S1YXgMGA4g,7145
-ophyd_async-0.13.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ophyd_async-0.13.1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.13.1.dist-info/RECORD,,
+ophyd_async-0.13.2.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.13.2.dist-info/METADATA,sha256=GwFtb0s8P44XeDTXV6U55G1tro_OERT4Vj-9aVrKomE,7177
+ophyd_async-0.13.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ophyd_async-0.13.2.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.13.2.dist-info/RECORD,,