mx-bluesky 1.4.4__py3-none-any.whl → 1.4.6__py3-none-any.whl

mx_bluesky/common/parameters/gridscan.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 from dodal.devices.aperturescatterguard import ApertureValue
+from dodal.devices.detector.det_dim_constants import EIGER2_X_9M_SIZE, EIGER2_X_16M_SIZE
+from dodal.devices.detector.detector import DetectorParams
 from dodal.devices.fast_grid_scan import (
     ZebraGridScanParams,
 )
+from dodal.utils import get_beamline_name
 from pydantic import Field, PrivateAttr
 from scanspec.core import Path as ScanPath
 from scanspec.specs import Line, Static
@@ -18,11 +21,12 @@ from mx_bluesky.common.parameters.components import (
     XyzStarts,
 )
 from mx_bluesky.common.parameters.constants import (
+    DetectorParamConstants,
     GridscanParamConstants,
     HardwareConstants,
 )
 
-"""Parameter models in this file are abstract. They should be inherited by a top-level model"""
+DETECTOR_SIZE_PER_BEAMLINE = {"i02-1": EIGER2_X_9M_SIZE, "dev": EIGER2_X_16M_SIZE}
 
 
 class GridCommon(
@@ -146,3 +150,34 @@ class SpecifiedThreeDGridScan(
     @property
     def num_images(self) -> int:
         return len(self.scan_points["sam_x"])
+
+    @property
+    def detector_params(self):
+        self.det_dist_to_beam_converter_path = (
+            self.det_dist_to_beam_converter_path
+            or DetectorParamConstants.BEAM_XY_LUT_PATH
+        )
+        optional_args = {}
+        if self.run_number:
+            optional_args["run_number"] = self.run_number
+        assert self.detector_distance_mm is not None, (
+            "Detector distance must be filled before generating DetectorParams"
+        )
+        return DetectorParams(
+            detector_size_constants=DETECTOR_SIZE_PER_BEAMLINE[
+                get_beamline_name("dev")
+            ],
+            expected_energy_ev=self.demand_energy_ev,
+            exposure_time=self.exposure_time_s,
+            directory=self.storage_directory,
+            prefix=self.file_name,
+            detector_distance=self.detector_distance_mm,
+            omega_start=self.omega_start_deg or 0,
+            omega_increment=0,
+            num_images_per_trigger=1,
+            num_triggers=self.num_images,
+            use_roi_mode=self.use_roi_mode,
+            det_dist_to_beam_converter_path=self.det_dist_to_beam_converter_path,
+            trigger_mode=self.trigger_mode,
+            **optional_args,
+        )

mx_bluesky/common/plans/do_fgs.py

@@ -14,12 +14,10 @@ from dodal.log import LOGGER
 from dodal.plan_stubs.check_topup import check_topup_and_wait_if_necessary
 from scanspec.core import AxesPoints, Axis
 
-from mx_bluesky.common.device_setup_plans.read_hardware_for_setup import (
-    read_hardware_for_zocalo,
-)
 from mx_bluesky.common.parameters.constants import (
     PlanNameConstants,
 )
+from mx_bluesky.common.plans.read_hardware import read_hardware_for_zocalo
 from mx_bluesky.common.utils.tracing import TRACER
 
 
@@ -30,7 +28,7 @@ def _wait_for_zocalo_to_stage_then_do_fgs(
     during_collection_plan: Callable[[], MsgGenerator] | None = None,
 ):
     expected_images = yield from bps.rd(grid_scan_device.expected_images)
-    exposure_sec_per_image = yield from bps.rd(detector.cam.acquire_time)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    exposure_sec_per_image = yield from bps.rd(detector.cam.acquire_time)  # type: ignore # Fix types in ophyd-async (https://github.com/DiamondLightSource/mx-bluesky/issues/855)
     LOGGER.info("waiting for topup if necessary...")
     yield from check_topup_and_wait_if_necessary(
         synchrotron,
@@ -101,8 +99,8 @@ def kickoff_and_complete_gridscan(
         }
     )
     @bpp.contingency_decorator(
-        except_plan=lambda e: (yield from bps.stop(detector)),  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        else_plan=lambda: (yield from bps.unstage(detector)),  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        except_plan=lambda e: (yield from bps.stop(detector)),  # type: ignore # Fix types in ophyd-async (https://github.com/DiamondLightSource/mx-bluesky/issues/855)
+        else_plan=lambda: (yield from bps.unstage(detector)),
     )
     def _decorated_do_fgs():
         yield from _wait_for_zocalo_to_stage_then_do_fgs(

mx_bluesky/common/plans/read_hardware.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import bluesky.plan_stubs as bps
+from bluesky.protocols import Readable
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.dcm import DCM
+from dodal.devices.eiger import EigerDetector
+from dodal.devices.flux import Flux
+from dodal.devices.s4_slit_gaps import S4SlitGaps
+from dodal.devices.smargon import Smargon
+from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.undulator import Undulator
+
+from mx_bluesky.common.parameters.constants import (
+    DocDescriptorNames,
+)
+from mx_bluesky.common.utils.log import LOGGER
+
+
+def read_hardware_plan(
+    signals: list[Readable],
+    event_name: str,
+):
+    LOGGER.info(f"Reading status of beamline for event, {event_name}")
+    yield from bps.create(name=event_name)
+    for signal in signals:
+        yield from bps.read(signal)
+    yield from bps.save()
+
+
+def read_hardware_for_zocalo(detector: EigerDetector):
+    """ "
+    If the RunEngine is subscribed to the ZocaloCallback, this plan will also trigger zocalo.
+    """
+    yield from read_hardware_plan(
+        [detector.odin.file_writer.id],  # type: ignore
+        DocDescriptorNames.ZOCALO_HW_READ,
+    )
+
+
+def standard_read_hardware_pre_collection(
+    undulator: Undulator,
+    synchrotron: Synchrotron,
+    s4_slit_gaps: S4SlitGaps,
+    dcm: DCM,
+    smargon: Smargon,
+):
+    LOGGER.info("Reading status of beamline for callbacks, pre collection.")
+    signals_to_read_pre_flyscan = [
+        undulator.current_gap,
+        synchrotron.synchrotron_mode,
+        s4_slit_gaps,
+        smargon,
+        dcm.energy_in_kev,
+    ]
+    yield from read_hardware_plan(
+        signals_to_read_pre_flyscan, DocDescriptorNames.HARDWARE_READ_PRE
+    )
+
+
+def standard_read_hardware_during_collection(
+    aperture_scatterguard: ApertureScatterguard,
+    attenuator: BinaryFilterAttenuator,
+    flux: Flux,
+    dcm: DCM,
+    detector: EigerDetector,
+):
+    signals_to_read_during_collection = [
+        aperture_scatterguard,
+        attenuator.actual_transmission,
+        flux.flux_reading,
+        dcm.energy_in_kev,
+        detector.bit_depth,
+    ]
+    yield from read_hardware_plan(
+        signals_to_read_during_collection, DocDescriptorNames.HARDWARE_READ_DURING
+    )

mx_bluesky/common/utils/context.py

@@ -0,0 +1,68 @@
+import dataclasses
+from typing import Any, ClassVar, Protocol, TypeVar, get_type_hints
+
+from blueapi.core import BlueskyContext
+from blueapi.core.bluesky_types import Device
+
+from mx_bluesky.common.utils.log import LOGGER
+
+T = TypeVar("T", bound=Device)
+
+
+class _IsDataclass(Protocol):
+    """Protocol followed by any dataclass"""
+
+    __dataclass_fields__: ClassVar[dict]
+
+
+DT = TypeVar("DT", bound=_IsDataclass)
+
+
+def find_device_in_context(
+    context: BlueskyContext,
+    name: str,
+    # Typing in here is wrong (see https://github.com/microsoft/pyright/issues/7228#issuecomment-1934500232)
+    # but this whole thing will go away when we do https://github.com/DiamondLightSource/hyperion/issues/868
+    expected_type: type[T] = Device,  # type: ignore
+) -> T:
+    LOGGER.debug(f"Looking for device {name} of type {expected_type} in context")
+
+    device = context.find_device(name)
+    if device is None:
+        raise ValueError(
+            f"Cannot find device named '{name}' in bluesky context {context.devices}."
+        )
+
+    if not isinstance(device, expected_type):
+        raise ValueError(
+            f"Found device named '{name}' and expected it to be a '{expected_type}' but it was a '{device.__class__.__name__}'"
+        )
+
+    LOGGER.debug(f"Found matching device {device}")
+    return device
+
+
+def device_composite_from_context(context: BlueskyContext, dc: type[DT]) -> DT:
+    """
+    Initializes all of the devices referenced in a given dataclass from a provided
+    context, checking that the types of devices returned by the context are compatible
+    with the type annotations of the dataclass.
+
+    Note that if the context was not created with `wait_for_connection=True` devices may
+    still be unconnected.
+    """
+    LOGGER.debug(
+        f"Attempting to initialize devices referenced in dataclass {dc} from blueapi context"
+    )
+
+    devices: dict[str, Any] = {}
+    dc_type_hints: dict[str, Any] = get_type_hints(dc)
+
+    for field in dataclasses.fields(dc):
+        device = find_device_in_context(
+            context, field.name, expected_type=dc_type_hints.get(field.name, Device)
+        )
+
+        devices[field.name] = device
+
+    return dc(**devices)

mx_bluesky/common/utils/exceptions.py

@@ -39,7 +39,8 @@ T = TypeVar("T")
 class CrystalNotFoundException(SampleException):
     """Raised if grid detection completed normally but no crystal was found."""
 
-    pass
+    def __init__(self, *args):
+        super().__init__("Diffraction not found, skipping sample.")
 
 
 def catch_exception_and_warn(

mx_bluesky/{hyperion/experiment_plans/common → common}/xrc_result.py

@@ -5,6 +5,8 @@ from collections.abc import Callable, Sequence
 from functools import partial
 
 import numpy as np
+from bluesky.callbacks import CallbackBase
+from event_model import RunStart
 
 from mx_bluesky.common.parameters.components import (
     MultiXtalSelection,
@@ -12,6 +14,20 @@ from mx_bluesky.common.parameters.components import (
 )
 
 
+class XRayCentreEventHandler(CallbackBase):
+    def __init__(self):
+        super().__init__()
+        self.xray_centre_results: Sequence[XRayCentreResult] | None = None
+
+    def start(self, doc: RunStart) -> RunStart | None:
+        if "xray_centre_results" in doc:
+            self.xray_centre_results = [
+                XRayCentreResult(**result_dict)
+                for result_dict in doc["xray_centre_results"]  # type: ignore
+            ]
+        return doc
+
+
 @dataclasses.dataclass
 class XRayCentreResult:
     """

mx_bluesky/definitions.py

@@ -0,0 +1,4 @@
+import os
+
+# Change once Python<3.12 is dropped - see https://github.com/DiamondLightSource/mx-bluesky/issues/798
+ROOT_DIR = os.path.dirname(os.path.abspath(__file__))

mx_bluesky/hyperion/__main__.py

@@ -4,6 +4,7 @@ import threading
 from collections.abc import Callable
 from dataclasses import asdict
 from queue import Queue
+from sys import argv
 from traceback import format_exception
 from typing import Any
 
@@ -37,11 +38,8 @@ from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     PLAN_REGISTRY,
     PlanNotFound,
 )
-from mx_bluesky.hyperion.external_interaction.callbacks.__main__ import (
-    setup_logging as setup_callback_logging,
-)
-from mx_bluesky.hyperion.external_interaction.callbacks.common.callback_util import (
-    CallbacksFactory,
+from mx_bluesky.hyperion.external_interaction.agamemnon import (
+    update_params_from_agamemnon,
 )
 from mx_bluesky.hyperion.parameters.cli import parse_cli_args
 from mx_bluesky.hyperion.parameters.constants import CONST
@@ -56,7 +54,6 @@ class Command:
     devices: Any | None = None
     experiment: Callable[[Any, Any], MsgGenerator] | None = None
     parameters: MxBlueskyParameters | None = None
-    callbacks: CallbacksFactory | None = None
 
 
 @dataclass
@@ -88,7 +85,6 @@ class BlueskyRunner:
         RE: RunEngine,
         context: BlueskyContext,
         skip_startup_connection=False,
-        use_external_callbacks: bool = False,
     ) -> None:
         self.command_queue: Queue[Command] = Queue()
         self.current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
@@ -99,15 +95,12 @@ class BlueskyRunner:
 
         self.RE = RE
         self.context = context
-        self.subscribed_per_plan_callbacks: list[int] = []
         RE.subscribe(self.aperture_change_callback)
         RE.subscribe(self.logging_uid_tag_callback)
 
-        self.use_external_callbacks = use_external_callbacks
-        if self.use_external_callbacks:
-            LOGGER.info("Connecting to external callback ZMQ proxy...")
-            self.publisher = Publisher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[0]}")
-            RE.subscribe(self.publisher)
+        LOGGER.info("Connecting to external callback ZMQ proxy...")
+        self.publisher = Publisher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[0]}")
+        RE.subscribe(self.publisher)
 
         if VERBOSE_EVENT_LOGGING:
             RE.subscribe(VerbosePlanExecutionLoggingCallback())
@@ -123,7 +116,6 @@ class BlueskyRunner:
         experiment: Callable,
         parameters: MxBlueskyParameters,
         plan_name: str,
-        callbacks: CallbacksFactory | None,
     ) -> StatusAndMessage:
         LOGGER.info(f"Started with parameters: {parameters.model_dump_json(indent=2)}")
 
@@ -142,7 +134,6 @@ class BlueskyRunner:
                     devices=devices,
                     experiment=experiment,
                     parameters=parameters,
-                    callbacks=callbacks,
                 )
             )
             return StatusAndMessage(Status.SUCCESS)
@@ -181,17 +172,6 @@ class BlueskyRunner:
                 if command.experiment is None:
                     raise ValueError("No experiment provided for START")
                 try:
-                    if (
-                        not self.use_external_callbacks
-                        and command.callbacks
-                        and (cbs := command.callbacks())
-                    ):
-                        LOGGER.info(
-                            f"Using callbacks for this plan: {not self.use_external_callbacks} - {cbs}"
-                        )
-                        self.subscribed_per_plan_callbacks += [
-                            self.RE.subscribe(cb) for cb in cbs
-                        ]
                     with TRACER.start_span("do_run"):
                         self.RE(command.experiment(command.devices, command.parameters))
 
@@ -212,11 +192,6 @@ class BlueskyRunner:
                         self.last_run_aborted = False
                     else:
                         self.current_status = make_error_status_and_message(exception)
-                finally:
-                    [
-                        self.RE.unsubscribe(cb)
-                        for cb in self.subscribed_per_plan_callbacks
-                    ]
 
 
 def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions):
@@ -225,7 +200,6 @@ def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions)
         raise PlanNotFound(f"Experiment plan '{plan_name}' not found in registry.")
 
     experiment_internal_param_type = experiment_registry_entry.get("param_type")
-    callback_type = experiment_registry_entry.get("callback_collection_type")
     plan = context.plan_functions.get(plan_name)
     if experiment_internal_param_type is None:
         raise PlanNotFound(
@@ -237,13 +211,14 @@ def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions)
         )
     try:
         parameters = experiment_internal_param_type(**json.loads(request.data))
+        parameters = update_params_from_agamemnon(parameters)
         if parameters.model_extra:
             raise ValueError(f"Extra fields not allowed {parameters.model_extra}")
     except Exception as e:
         raise ValueError(
             f"Supplied parameters don't match the plan for this endpoint {request.data}, for plan {plan_name}"
         ) from e
-    return plan, parameters, plan_name, callback_type
+    return plan, parameters, plan_name
 
 
 class RunExperiment(Resource):
@@ -256,12 +231,10 @@ class RunExperiment(Resource):
         status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
         if action == Actions.START.value:
             try:
-                plan, params, plan_name, callback_type = compose_start_args(
+                plan, params, plan_name = compose_start_args(
                     self.context, plan_name, action
                 )
-                status_and_message = self.runner.start(
-                    plan, params, plan_name, callback_type
-                )
+                status_and_message = self.runner.start(plan, params, plan_name)
             except Exception as e:
                 status_and_message = make_error_status_and_message(e)
                 LOGGER.error(format_exception(e))
@@ -312,7 +285,6 @@ def create_app(
     test_config=None,
     RE: RunEngine = RunEngine({}),
     skip_startup_connection: bool = False,
-    use_external_callbacks: bool = False,
 ) -> tuple[Flask, BlueskyRunner]:
     context = setup_context(
         wait_for_connection=not skip_startup_connection,
@@ -320,7 +292,6 @@ def create_app(
     runner = BlueskyRunner(
         RE,
         context=context,
-        use_external_callbacks=use_external_callbacks,
         skip_startup_connection=skip_startup_connection,
     )
     app = Flask(__name__)
@@ -350,11 +321,9 @@ def create_targets():
     do_default_logging_setup(
         CONST.LOG_FILE_NAME, CONST.GRAYLOG_PORT, dev_mode=args.dev_mode
     )
-    if not args.use_external_callbacks:
-        setup_callback_logging(args.dev_mode)
+    LOGGER.info(f"Hyperion launched with args:{argv}")
     app, runner = create_app(
         skip_startup_connection=args.skip_startup_connection,
-        use_external_callbacks=args.use_external_callbacks,
     )
     return app, runner, hyperion_port, args.dev_mode
 

mx_bluesky/hyperion/device_setup_plans/setup_oav.py

@@ -55,14 +55,14 @@ def setup_pin_tip_detection_params(
 
 
 def setup_general_oav_params(oav: OAV, parameters: OAVParameters):
-    yield from set_using_group(oav.cam.color_mode, ColorMode.RGB1)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-    yield from set_using_group(oav.cam.acquire_period, parameters.acquire_period)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-    yield from set_using_group(oav.cam.acquire_time, parameters.exposure)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-    yield from set_using_group(oav.cam.gain, parameters.gain)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from set_using_group(oav.cam.color_mode, ColorMode.RGB1)
+    yield from set_using_group(oav.cam.acquire_period, parameters.acquire_period)
+    yield from set_using_group(oav.cam.acquire_time, parameters.exposure)
+    yield from set_using_group(oav.cam.gain, parameters.gain)
 
     zoom_level_str = f"{float(parameters.zoom)}x"
     yield from bps.abs_set(
-        oav.zoom_controller,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        oav.zoom_controller,
         zoom_level_str,
         wait=True,
     )

mx_bluesky/hyperion/device_setup_plans/setup_panda.py

@@ -1,6 +1,5 @@
 from datetime import datetime
 from enum import Enum
-from importlib import resources
 from pathlib import Path
 
 import bluesky.plan_stubs as bps
@@ -8,15 +7,15 @@ from bluesky.utils import MsgGenerator
 from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.devices.fast_grid_scan import PandAGridScanParams
 from dodal.devices.smargon import Smargon
-from ophyd_async.core import load_device
 from ophyd_async.fastcs.panda import (
     HDFPanda,
     SeqTable,
     SeqTrigger,
 )
 
-import mx_bluesky.hyperion.resources.panda as panda_resource
+from mx_bluesky.common.device_setup_plans.setup_panda import load_panda_from_yaml
 from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.hyperion.parameters.constants import DeviceSettingsConstants
 
 MM_TO_ENCODER_COUNTS = 200000
 GENERAL_TIMEOUT = 60
@@ -76,7 +75,8 @@ def _get_seq_table(
 
     num_pulses = parameters.x_steps
 
-    delay_between_pulses = time_between_steps_ms * TICKS_PER_MS
+    # Integer precision here is 1e-6s, so casting is safe
+    delay_between_pulses = int(time_between_steps_ms * TICKS_PER_MS)
 
     assert delay_between_pulses > PULSE_WIDTH_US
 
@@ -145,10 +145,11 @@ def setup_panda_for_flyscan(
 
     yield from bps.stage(panda, group="panda-config")
 
-    with resources.as_file(
-        resources.files(panda_resource) / "panda-gridscan.yaml"
-    ) as config_yaml_path:
-        yield from load_device(panda, str(config_yaml_path))
+    yield from load_panda_from_yaml(
+        DeviceSettingsConstants.PANDA_FLYSCAN_SETTINGS_DIR,
+        DeviceSettingsConstants.PANDA_FLYSCAN_SETTINGS_FILENAME,
+        panda,
+    )
 
     initial_x = yield from bps.rd(smargon.x.user_readback)
     initial_y = yield from bps.rd(smargon.y.user_readback)

mx_bluesky/hyperion/device_setup_plans/setup_zebra.py

@@ -47,7 +47,7 @@ def bluesky_retry(func: Callable):
 
 
 def arm_zebra(zebra: Zebra):
-    yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)
 
 
 def tidy_up_zebra_after_rotation_scan(
@@ -56,7 +56,7 @@ def tidy_up_zebra_after_rotation_scan(
     group="tidy_up_zebra_after_rotation",
     wait=True,
 ):
-    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, group=group)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, group=group)
     yield from bps.abs_set(
         zebra_shutter.control_mode, ZebraShutterControl.MANUAL, group=group
     )

mx_bluesky/hyperion/device_setup_plans/smargon.py

@@ -16,10 +16,10 @@ def move_smargon_warn_on_out_of_range(
             "Pin tip centring failed - pin too long/short/bent and out of range"
         )
     yield from bps.mv(
-        smargon.x,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        position[0],  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        smargon.y,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        position[1],  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        smargon.z,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        position[2],  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.x,
+        position[0],
+        smargon.y,
+        position[1],
+        smargon.z,
+        position[2],
     )

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -44,7 +44,7 @@ def start_preparing_data_collection_then_do_plan(
     """
 
     def wrapped_plan():
-        yield from bps.abs_set(eiger.do_arm, 1, group=group)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.abs_set(eiger.do_arm, 1, group=group)  # type: ignore # Fix types in ophyd-async (https://github.com/DiamondLightSource/mx-bluesky/issues/855)
         if detector_distance_mm:
             yield from set_detector_z_position(
                 detector_motion, detector_distance_mm, group
@@ -55,5 +55,5 @@ def start_preparing_data_collection_then_do_plan(
     yield from check_beamstop(beamstop)
     yield from bpp.contingency_wrapper(
         wrapped_plan(),
-        except_plan=lambda e: (yield from bps.stop(eiger)),  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        except_plan=lambda e: (yield from bps.stop(eiger)),  # type: ignore # Fix types in ophyd-async (https://github.com/DiamondLightSource/mx-bluesky/issues/855)
     )

mx_bluesky/hyperion/device_setup_plans/xbpm_feedback.py

@@ -2,6 +2,8 @@ from bluesky import plan_stubs as bps
 from bluesky.preprocessors import finalize_wrapper
 from bluesky.utils import make_decorator
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.dcm import DCM
+from dodal.devices.undulator import Undulator
 from dodal.devices.xbpm_feedback import Pause, XBPMFeedback
 
 from mx_bluesky.common.utils.log import LOGGER
@@ -23,14 +25,14 @@ def _check_and_pause_feedback(
                                                turning XBPM feedback off.
 
     """
-    yield from bps.mv(attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.mv(attenuator, 1.0)
     LOGGER.info("Waiting for XBPM feedback to be stable")
     yield from bps.trigger(xbpm_feedback, wait=True)
     LOGGER.info(
         f"XPBM feedback in position, pausing and setting transmission to {desired_transmission_fraction}"
     )
-    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.PAUSE)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-    yield from bps.mv(attenuator, desired_transmission_fraction)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.PAUSE)
+    yield from bps.mv(attenuator, desired_transmission_fraction)
 
 
 def _unpause_xbpm_feedback_and_set_transmission_to_1(
@@ -44,13 +46,15 @@ def _unpause_xbpm_feedback_and_set_transmission_to_1(
                                       the beam in position
         attenuator (BinaryFilterAttenuator): The attenuator used to set transmission
     """
-    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)
 
 
 def transmission_and_xbpm_feedback_for_collection_wrapper(
     plan,
+    undulator: Undulator,
     xbpm_feedback: XBPMFeedback,
     attenuator: BinaryFilterAttenuator,
+    dcm: DCM,
     desired_transmission_fraction: float,
 ):
     """Sets the transmission for the data collection, ensuring the xbpm feedback is valid
@@ -66,6 +70,9 @@ def transmission_and_xbpm_feedback_for_collection_wrapper(
     mostly accounts for slow thermal drift so it is safe to assume that the beam is
     stable during a collection.
 
+    In the case of a beam dump, undulator gap may not return. Therefore, we check here
+    that the undulator gap is correct after XBPM is stable, and before collection.
+
     Args:
         plan: The plan performing the data collection
         xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
@@ -78,6 +85,9 @@ def transmission_and_xbpm_feedback_for_collection_wrapper(
         yield from _check_and_pause_feedback(
             xbpm_feedback, attenuator, desired_transmission_fraction
         )
+        # Verify Undulator gap is correct, as may not be after a beam dump
+        energy_in_kev = yield from bps.rd(dcm.energy_in_kev.user_readback)
+        yield from bps.abs_set(undulator, energy_in_kev, wait=True)
         return (yield from plan)
 
     return (

mx_bluesky/hyperion/experiment_plans/change_aperture_then_move_plan.py

@@ -6,8 +6,8 @@ from dodal.devices.smargon import Smargon, StubPosition
 
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.utils.tracing import TRACER
+from mx_bluesky.common.xrc_result import XRayCentreResult
 from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import move_x_y_z
-from mx_bluesky.hyperion.experiment_plans.common.xrc_result import XRayCentreResult
 from mx_bluesky.hyperion.parameters.gridscan import HyperionSpecifiedThreeDGridScan
 
 
@@ -43,11 +43,7 @@ def change_aperture_then_move_to_xtal(
     # https://github.com/DiamondLightSource/mx-bluesky/issues/552
     if parameters and parameters.FGS_params.set_stub_offsets:
         LOGGER.info("Recentring smargon co-ordinate system to this point.")
-        yield from bps.mv(
-            # See: https://github.com/bluesky/bluesky/issues/1809
-            smargon.stub_offsets,  # type: ignore
-            StubPosition.CURRENT_AS_CENTER,  # type: ignore
-        )
+        yield from bps.mv(smargon.stub_offsets, StubPosition.CURRENT_AS_CENTER)
 
 
 def set_aperture_for_bbox_mm(