mx-bluesky 1.2.0__py3-none-any.whl → 1.4.1a0__py3-none-any.whl

mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -1,25 +1,36 @@
-import dataclasses
+from collections.abc import Sequence
 
-from blueapi.core import BlueskyContext
+import pydantic
+from blueapi.core import BlueskyContext, MsgGenerator
+from bluesky.preprocessors import subs_wrapper
 from dodal.devices.oav.oav_parameters import OAVParameters
+from dodal.devices.smargon import Smargon
 
+import mx_bluesky.hyperion.experiment_plans.common.xrc_result as flyscan_result
+from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
+    XRayCentreEventHandler,
+)
 from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
     RobotLoadThenCentreComposite,
-    robot_load_then_centre,
+    robot_load_then_xray_centre,
 )
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
+    MultiRotationScan,
     RotationScanComposite,
     multi_rotation_scan,
 )
+from mx_bluesky.hyperion.log import LOGGER
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class LoadCentreCollectComposite(RobotLoadThenCentreComposite, RotationScanComposite):
     """Composite that provides access to the required devices."""
 
-    pass
+    @property
+    def sample_motors(self) -> Smargon:
+        return self.smargon
 
 
 def create_devices(context: BlueskyContext) -> LoadCentreCollectComposite:
@@ -27,11 +38,11 @@ def create_devices(context: BlueskyContext) -> LoadCentreCollectComposite:
     return device_composite_from_context(context, LoadCentreCollectComposite)
 
 
-def load_centre_collect_full_plan(
+def load_centre_collect_full(
     composite: LoadCentreCollectComposite,
-    params: LoadCentreCollect,
+    parameters: LoadCentreCollect,
     oav_params: OAVParameters | None = None,
-):
+) -> MsgGenerator:
     """Attempt a complete data collection experiment, consisting of the following:
     * Load the sample if necessary
     * Move to the specified goniometer start angles
@@ -41,6 +52,37 @@ def load_centre_collect_full_plan(
     """
     if not oav_params:
         oav_params = OAVParameters(context="xrayCentring")
-    yield from robot_load_then_centre(composite, params.robot_load_then_centre)
 
-    yield from multi_rotation_scan(composite, params.multi_rotation_scan, oav_params)
+    flyscan_event_handler = XRayCentreEventHandler()
+    yield from subs_wrapper(
+        robot_load_then_xray_centre(composite, parameters.robot_load_then_centre),
+        flyscan_event_handler,
+    )
+
+    assert (
+        flyscan_event_handler.xray_centre_results
+    ), "Flyscan result event not received or no crystal found and exception not raised"
+
+    selection_func = flyscan_result.resolve_selection_fn(parameters.selection_params)
+    hits: Sequence[flyscan_result.XRayCentreResult] = selection_func(
+        flyscan_event_handler.xray_centre_results
+    )
+    LOGGER.info(
+        f"Selected hits {hits} using {selection_func}, args={parameters.selection_params}"
+    )
+
+    multi_rotation = parameters.multi_rotation_scan
+    rotation_template = multi_rotation.rotation_scans.copy()
+
+    multi_rotation.rotation_scans.clear()
+
+    for hit in hits:
+        for rot in rotation_template:
+            combination = rot.model_copy()
+            combination.x_start_um, combination.y_start_um, combination.z_start_um = (
+                axis * 1000 for axis in hit.centre_of_mass_mm
+            )
+            multi_rotation.rotation_scans.append(combination)
+    multi_rotation = MultiRotationScan.model_validate(multi_rotation)
+
+    yield from multi_rotation_scan(composite, multi_rotation, oav_params)

mx_bluesky/hyperion/experiment_plans/oav_grid_detection_plan.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-import dataclasses
 import math
 from typing import TYPE_CHECKING
 
 import bluesky.plan_stubs as bps
 import numpy as np
+import pydantic
 from blueapi.core import BlueskyContext
 from dodal.devices.backlight import Backlight
 from dodal.devices.oav.oav_detector import OAV
@@ -26,7 +26,7 @@ if TYPE_CHECKING:
     from dodal.devices.oav.oav_parameters import OAVParameters
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class OavGridDetectionComposite:
     """All devices which are directly or indirectly required by this plan"""
 
@@ -63,7 +63,7 @@ def grid_detection_plan(
     snapshot_template: str,
     snapshot_dir: str,
     grid_width_microns: float,
-    box_size_um: float = 20,
+    box_size_um: float,
 ):
     """
     Creates the parameters for two grids that are 90 degrees from each other and
@@ -74,7 +74,7 @@ def grid_detection_plan(
         parameters (OAVParameters): Object containing parameters for setting up the OAV
         snapshot_template (str): A template for the name of the snapshots, expected to be filled in with an angle
         snapshot_dir (str): The location to save snapshots
-        grid_width_microns (int): The width of the grid to scan in microns
+        grid_width_microns (float): The width of the grid to scan in microns
         box_size_um (float): The size of each box of the grid in microns
     """
     oav: OAV = composite.oav
@@ -90,16 +90,17 @@ def grid_detection_plan(
 
     LOGGER.info("OAV Centring: Camera set up")
 
-    assert isinstance(oav.parameters.micronsPerXPixel, float)
-    box_size_x_pixels = box_size_um / oav.parameters.micronsPerXPixel
-    assert isinstance(oav.parameters.micronsPerYPixel, float)
-    box_size_y_pixels = box_size_um / oav.parameters.micronsPerYPixel
+    microns_per_pixel_x = yield from bps.rd(oav.microns_per_pixel_x)
+    microns_per_pixel_y = yield from bps.rd(oav.microns_per_pixel_y)
 
-    grid_width_pixels = int(grid_width_microns / oav.parameters.micronsPerXPixel)
+    box_size_x_pixels = box_size_um / microns_per_pixel_x
+    box_size_y_pixels = box_size_um / microns_per_pixel_y
+
+    grid_width_pixels = int(grid_width_microns / microns_per_pixel_x)
 
     # The FGS uses -90 so we need to match it
     for angle in [0, -90]:
-        yield from bps.mv(smargon.omega, angle)
+        yield from bps.mv(smargon.omega, angle)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
         # need to wait for the OAV image to update
         # See #673 for improvements
         yield from bps.sleep(CONST.HARDWARE.OAV_REFRESH_DELAY)
@@ -115,7 +116,7 @@ def grid_detection_plan(
             (yield from bps.rd(pin_tip_detection.triggered_bottom_edge))
         )
 
-        full_image_height_px = yield from bps.rd(oav.cam.array_size.array_size_y)
+        full_image_height_px = yield from bps.rd(oav.cam.array_size_y)
 
         # only use the area from the start of the pin onwards
         top_edge = top_edge[tip_x_px : tip_x_px + grid_width_pixels]
@@ -151,20 +152,20 @@ def grid_detection_plan(
 
         upper_left = (tip_x_px, min_y)
 
-        yield from bps.abs_set(oav.grid_snapshot.top_left_x, upper_left[0])
-        yield from bps.abs_set(oav.grid_snapshot.top_left_y, upper_left[1])
-        yield from bps.abs_set(oav.grid_snapshot.box_width, box_size_x_pixels)
-        yield from bps.abs_set(oav.grid_snapshot.num_boxes_x, x_steps)
-        yield from bps.abs_set(oav.grid_snapshot.num_boxes_y, y_steps)
+        yield from bps.abs_set(oav.grid_snapshot.top_left_x, upper_left[0])  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.abs_set(oav.grid_snapshot.top_left_y, upper_left[1])  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.abs_set(oav.grid_snapshot.box_width, box_size_x_pixels)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.abs_set(oav.grid_snapshot.num_boxes_x, x_steps)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.abs_set(oav.grid_snapshot.num_boxes_y, y_steps)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
         snapshot_filename = snapshot_template.format(angle=abs(angle))
 
-        yield from bps.abs_set(oav.grid_snapshot.filename, snapshot_filename)
-        yield from bps.abs_set(oav.grid_snapshot.directory, snapshot_dir)
-        yield from bps.trigger(oav.grid_snapshot, wait=True)
+        yield from bps.abs_set(oav.grid_snapshot.filename, snapshot_filename)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.abs_set(oav.grid_snapshot.directory, snapshot_dir)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.trigger(oav.grid_snapshot, wait=True)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
         yield from bps.create(CONST.DESCRIPTORS.OAV_GRID_SNAPSHOT_TRIGGERED)
 
-        yield from bps.read(oav.grid_snapshot)
+        yield from bps.read(oav)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
         yield from bps.read(smargon)
         yield from bps.save()
 

mx_bluesky/hyperion/experiment_plans/oav_snapshot_plan.py

@@ -1,16 +1,16 @@
 from datetime import datetime
 from typing import Protocol
 
-from blueapi.core import MsgGenerator
 from bluesky import plan_stubs as bps
-from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
+from bluesky.utils import MsgGenerator
+from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.backlight import Backlight, BacklightPosition
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAVParameters
 from dodal.devices.smargon import Smargon
 
+from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.hyperion.device_setup_plans.setup_oav import setup_general_oav_params
-from mx_bluesky.hyperion.parameters.components import WithSnapshot
 from mx_bluesky.hyperion.parameters.constants import CONST, DocDescriptorNames
 
 OAV_SNAPSHOT_SETUP_SHOT = "oav_snapshot_setup_shot"
@@ -33,22 +33,16 @@ def setup_beamline_for_OAV(
     max_vel = yield from bps.rd(smargon.omega.max_velocity)
     yield from bps.abs_set(smargon.omega.velocity, max_vel, group=group)
     yield from bps.abs_set(backlight, BacklightPosition.IN, group=group)
-    yield from bps.abs_set(
-        aperture_scatterguard,
-        ApertureValue.ROBOT_LOAD,
-        group=group,
-    )
+    yield from bps.trigger(aperture_scatterguard.move_out, group=group)
 
 
 def oav_snapshot_plan(
     composite: OavSnapshotComposite,
     parameters: WithSnapshot,
     oav_parameters: OAVParameters,
-    wait: bool = True,
 ) -> MsgGenerator:
     if not parameters.take_snapshots:
         return
-    yield from bps.wait(group=CONST.WAIT.READY_FOR_OAV)
     yield from _setup_oav(composite, parameters, oav_parameters)
     for omega in parameters.snapshot_omegas_deg or []:
         yield from _take_oav_snapshot(composite, omega)
@@ -61,7 +55,8 @@ def _setup_oav(
 ):
     yield from setup_general_oav_params(composite.oav, oav_parameters)
     yield from bps.abs_set(
-        composite.oav.snapshot.directory, str(parameters.snapshot_directory)
+        composite.oav.snapshot.directory,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        str(parameters.snapshot_directory),
     )
 
 
@@ -72,10 +67,12 @@ def _take_oav_snapshot(composite: OavSnapshotComposite, omega: float):
     time_now = datetime.now()
     filename = f"{time_now.strftime('%H%M%S')}_oav_snapshot_{omega:.0f}"
     yield from bps.abs_set(
-        composite.oav.snapshot.filename, filename, group=OAV_SNAPSHOT_SETUP_SHOT
+        composite.oav.snapshot.filename,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        filename,
+        group=OAV_SNAPSHOT_SETUP_SHOT,
     )
     yield from bps.wait(group=OAV_SNAPSHOT_SETUP_SHOT)
-    yield from bps.trigger(composite.oav.snapshot, wait=True)
+    yield from bps.trigger(composite.oav.snapshot, wait=True)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
-    yield from bps.read(composite.oav.snapshot)
+    yield from bps.read(composite.oav.snapshot)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     yield from bps.save()

mx_bluesky/hyperion/experiment_plans/optimise_attenuation_plan.py

@@ -1,9 +1,9 @@
-import dataclasses
 from enum import Enum
 
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
 import numpy as np
+import pydantic
 from blueapi.core import BlueskyContext
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.xspress3.xspress3 import Xspress3
@@ -22,7 +22,7 @@ class Direction(Enum):
     NEGATIVE = "negative"
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class OptimizeAttenuationComposite:
     """All devices which are directly or indirectly required by this plan"""
 

mx_bluesky/hyperion/experiment_plans/pin_centre_then_xray_centre_plan.py

@@ -2,14 +2,27 @@ from __future__ import annotations
 
 import json
 
-from blueapi.core import BlueskyContext, MsgGenerator
+import bluesky.preprocessors as bpp
+from blueapi.core import BlueskyContext
+from bluesky.utils import MsgGenerator
 from dodal.devices.eiger import EigerDetector
-from dodal.devices.oav.oav_parameters import OAV_CONFIG_JSON, OAVParameters
+from dodal.devices.oav.oav_parameters import OAVParameters
 
+from mx_bluesky.common.parameters.constants import OavConstants
+from mx_bluesky.common.parameters.gridscan import (
+    GridScanWithEdgeDetect,
+    PinTipCentreThenXrayCentre,
+)
 from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import move_phi_chi_omega
 from mx_bluesky.hyperion.device_setup_plans.utils import (
     start_preparing_data_collection_then_do_plan,
 )
+from mx_bluesky.hyperion.experiment_plans.change_aperture_then_move_plan import (
+    change_aperture_then_move_to_xtal,
+)
+from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
+    XRayCentreEventHandler,
+)
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     GridDetectThenXRayCentreComposite,
     detect_grid_and_do_gridscan,
@@ -26,10 +39,6 @@ from mx_bluesky.hyperion.external_interaction.callbacks.xray_centre.ispyb_callba
 )
 from mx_bluesky.hyperion.log import LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.gridscan import (
-    GridScanWithEdgeDetect,
-    PinTipCentreThenXrayCentre,
-)
 from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 
@@ -52,14 +61,12 @@ def create_parameters_for_grid_detection(
     return grid_detect_and_xray_centre
 
 
-def pin_centre_then_xray_centre_plan(
+def pin_centre_then_flyscan_plan(
     composite: GridDetectThenXRayCentreComposite,
     parameters: PinTipCentreThenXrayCentre,
-    oav_config_file: str = OAV_CONFIG_JSON,
+    oav_config_file: str = OavConstants.OAV_CONFIG_JSON,
 ):
-    """Plan that perfoms a pin tip centre followed by an xray centre to completely
-    centre the sample"""
-    oav_config_file = parameters.oav_centring_file
+    """Plan that performs a pin tip centre followed by a flyscan to determine the centres of interest"""
 
     pin_tip_centring_composite = PinTipCentringComposite(
         oav=composite.oav,
@@ -68,7 +75,7 @@ def pin_centre_then_xray_centre_plan(
         pin_tip_detection=composite.pin_tip_detection,
     )
 
-    def _pin_centre_then_xray_centre_plan():
+    def _pin_centre_then_flyscan_plan():
         yield from setup_beamline_for_OAV(
             composite.smargon, composite.backlight, composite.aperture_scatterguard
         )
@@ -96,24 +103,36 @@ def pin_centre_then_xray_centre_plan(
             oav_params,
         )
 
-    yield from ispyb_activation_wrapper(_pin_centre_then_xray_centre_plan(), parameters)
+    yield from ispyb_activation_wrapper(_pin_centre_then_flyscan_plan(), parameters)
 
 
 def pin_tip_centre_then_xray_centre(
     composite: GridDetectThenXRayCentreComposite,
     parameters: PinTipCentreThenXrayCentre,
-    oav_config_file: str = OAV_CONFIG_JSON,
+    oav_config_file: str = OavConstants.OAV_CONFIG_JSON,
 ) -> MsgGenerator:
     """Starts preparing for collection then performs the pin tip centre and xray centre"""
-
     eiger: EigerDetector = composite.eiger
 
     eiger.set_detector_parameters(parameters.detector_params)
 
-    return start_preparing_data_collection_then_do_plan(
-        eiger,
-        composite.detector_motion,
-        parameters.detector_params.detector_distance,
-        pin_centre_then_xray_centre_plan(composite, parameters, oav_config_file),
-        group=CONST.WAIT.GRID_READY_FOR_DC,
+    flyscan_event_handler = XRayCentreEventHandler()
+
+    @bpp.subs_decorator(flyscan_event_handler)
+    def pin_centre_flyscan_then_fetch_results() -> MsgGenerator:
+        yield from start_preparing_data_collection_then_do_plan(
+            eiger,
+            composite.detector_motion,
+            parameters.detector_params.detector_distance,
+            pin_centre_then_flyscan_plan(composite, parameters, oav_config_file),
+            group=CONST.WAIT.GRID_READY_FOR_DC,
+        )
+
+    yield from pin_centre_flyscan_then_fetch_results()
+    flyscan_results = flyscan_event_handler.xray_centre_results
+    assert (
+        flyscan_results
+    ), "Flyscan result event not received or no crystal found and exception not raised"
+    yield from change_aperture_then_move_to_xtal(
+        flyscan_results[0], composite.smargon, composite.aperture_scatterguard
     )

mx_bluesky/hyperion/experiment_plans/pin_tip_centring_plan.py

@@ -1,13 +1,13 @@
-import dataclasses
 from collections.abc import Generator
 
 import bluesky.plan_stubs as bps
+import pydantic
 from blueapi.core import BlueskyContext
 from bluesky.utils import Msg
 from dodal.devices.backlight import Backlight
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAV_CONFIG_JSON, OAVParameters
-from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.oav.pin_image_recognition import PinTipDetection, Tip
 from dodal.devices.oav.utils import (
     Pixel,
     get_move_required_so_that_beam_is_at_pixel,
@@ -27,7 +27,7 @@ from mx_bluesky.hyperion.utils.context import device_composite_from_context
 DEFAULT_STEP_SIZE = 0.5
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class PinTipCentringComposite:
     """All devices which are directly or indirectly required by this plan"""
 
@@ -43,11 +43,11 @@ def create_devices(context: BlueskyContext) -> PinTipCentringComposite:
 
 def trigger_and_return_pin_tip(
     pin_tip: PinTipDetection,
-) -> Generator[Msg, None, Pixel]:
+) -> Generator[Msg, None, Tip]:
     yield from bps.trigger(pin_tip, wait=True)
     tip_x_y_px = yield from bps.rd(pin_tip.triggered_tip)
     LOGGER.info(f"Pin tip found at {tip_x_y_px}")
-    return tip_x_y_px  # type: ignore
+    return tip_x_y_px
 
 
 def move_pin_into_view(
@@ -74,16 +74,16 @@ def move_pin_into_view(
         Tuple[int, int]: The location of the pin tip in pixels
     """
 
-    def pin_tip_valid(pin_x: float):
-        return pin_x != 0 and pin_x != pin_tip_device.INVALID_POSITION[0]
+    def pin_tip_valid(pin_xy: Tip):
+        return not all(pin_xy == pin_tip_device.INVALID_POSITION) and pin_xy[0] != 0
 
     for _ in range(max_steps):
-        tip_x_px, tip_y_px = yield from trigger_and_return_pin_tip(pin_tip_device)
+        tip_xy_px = yield from trigger_and_return_pin_tip(pin_tip_device)
 
-        if pin_tip_valid(tip_x_px):
-            return (tip_x_px, tip_y_px)
+        if pin_tip_valid(tip_xy_px):
+            return (int(tip_xy_px[0]), int(tip_xy_px[1]))
 
-        if tip_x_px == 0:
+        if tip_xy_px[0] == 0:
             # Pin is off in the -ve direction
             step_size_mm = -step_size_mm
 
@@ -97,19 +97,19 @@ def move_pin_into_view(
                 f"Pin tip is off screen, and moving {step_size_mm} mm would cross limits, "
                 f"moving to {move_within_limits} instead"
             )
-        yield from bps.mv(smargon.x, move_within_limits)
+        yield from bps.mv(smargon.x, move_within_limits)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
         # Some time for the view to settle after the move
         yield from bps.sleep(CONST.HARDWARE.OAV_REFRESH_DELAY)
 
-    tip_x_px, tip_y_px = yield from trigger_and_return_pin_tip(pin_tip_device)
+    tip_xy_px = yield from trigger_and_return_pin_tip(pin_tip_device)
 
-    if not pin_tip_valid(tip_x_px):
+    if not pin_tip_valid(tip_xy_px):
         raise WarningException(
             "Pin tip centring failed - pin too long/short/bent and out of range"
         )
     else:
-        return (tip_x_px, tip_y_px)
+        return (int(tip_xy_px[0]), int(tip_xy_px[1]))
 
 
 def pin_tip_centre_plan(
@@ -132,13 +132,13 @@ def pin_tip_centre_plan(
     pin_tip_setup = composite.pin_tip_detection
     pin_tip_detect = composite.pin_tip_detection
 
-    assert oav.parameters.micronsPerXPixel is not None
-    tip_offset_px = int(tip_offset_microns / oav.parameters.micronsPerXPixel)
+    microns_per_pixel_x = yield from bps.rd(oav.microns_per_pixel_x)
+    tip_offset_px = int(tip_offset_microns / microns_per_pixel_x)
 
     def offset_and_move(tip: Pixel):
         pixel_to_move_to = (tip[0] + tip_offset_px, tip[1])
         position_mm = yield from get_move_required_so_that_beam_is_at_pixel(
-            smargon, pixel_to_move_to, oav.parameters
+            smargon, pixel_to_move_to, oav
         )
         LOGGER.info(f"Tip centring moving to : {position_mm}")
         yield from move_smargon_warn_on_out_of_range(smargon, position_mm)
@@ -154,7 +154,7 @@ def pin_tip_centre_plan(
     tip = yield from move_pin_into_view(pin_tip_detect, smargon)
     yield from offset_and_move(tip)
 
-    yield from bps.mvr(smargon.omega, 90)
+    yield from bps.mvr(smargon.omega, 90)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
     # need to wait for the OAV image to update
     # See #673 for improvements

mx_bluesky/hyperion/experiment_plans/robot_load_and_change_energy.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import dataclasses
 from collections.abc import Generator
 from datetime import datetime
 from pathlib import Path
@@ -8,12 +7,13 @@ from typing import cast
 
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
+import pydantic
 from blueapi.core import BlueskyContext
 from bluesky.utils import Msg
-from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
+from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.dcm import DCM
-from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, VFMMirrorVoltages
+from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, MirrorVoltages
 from dodal.devices.motors import XYZPositioner
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.robot import BartRobot, SampleLocation
@@ -22,22 +22,22 @@ from dodal.devices.thawer import Thawer
 from dodal.devices.undulator_dcm import UndulatorDCM
 from dodal.devices.webcam import Webcam
 from dodal.devices.xbpm_feedback import XBPMFeedback
-from dodal.plans.motor_util_plans import MoveTooLarge, home_and_reset_wrapper
+from dodal.plan_stubs.motor_utils import MoveTooLarge, home_and_reset_wrapper
 
+from mx_bluesky.common.parameters.robot_load import RobotLoadAndEnergyChange
 from mx_bluesky.hyperion.experiment_plans.set_energy_plan import (
     SetEnergyComposite,
     set_energy_plan,
 )
 from mx_bluesky.hyperion.log import LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.robot_load import RobotLoadAndEnergyChange
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class RobotLoadAndEnergyChangeComposite:
     # SetEnergyComposite fields
     vfm: FocusingMirrorWithStripes
-    vfm_mirror_voltages: VFMMirrorVoltages
+    mirror_voltages: MirrorVoltages
     dcm: DCM
     undulator_dcm: UndulatorDCM
     xbpm_feedback: XBPMFeedback
@@ -94,21 +94,19 @@ def take_robot_snapshots(oav: OAV, webcam: Webcam, directory: Path):
 def prepare_for_robot_load(
     aperture_scatterguard: ApertureScatterguard, smargon: Smargon
 ):
-    yield from bps.abs_set(
-        aperture_scatterguard,
-        ApertureValue.ROBOT_LOAD,
-        group="prepare_robot_load",
-    )
+    yield from bps.trigger(aperture_scatterguard.move_out, group="prepare_robot_load")
 
-    yield from bps.mv(smargon.stub_offsets, StubPosition.RESET_TO_ROBOT_LOAD)
+    yield from bps.mv(smargon.stub_offsets, StubPosition.RESET_TO_ROBOT_LOAD)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
     # fmt: off
-    yield from bps.mv(smargon.x, 0,
-                      smargon.y, 0,
-                      smargon.z, 0,
-                      smargon.omega, 0,
-                      smargon.chi, 0,
-                      smargon.phi, 0)
+    yield from bps.mv(
+        smargon.x, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.y, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.z, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.omega, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.chi, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.phi, 0  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    )
     # fmt: on
 
     yield from bps.wait("prepare_robot_load")
@@ -135,7 +133,9 @@ def do_robot_load(
     yield from bps.wait("robot_load")
 
     yield from bps.abs_set(
-        composite.thawer.thaw_for_time_s, thawing_time, group="thawing_finished"
+        composite.thawer.thaw_for_time_s,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        thawing_time,
+        group="thawing_finished",
     )
     yield from wait_for_smargon_not_disabled(composite.smargon)
 
@@ -195,7 +195,7 @@ def robot_load_and_snapshots(
 
     yield from bps.create(name=CONST.DESCRIPTORS.ROBOT_LOAD)
     yield from bps.read(composite.robot.barcode)
-    yield from bps.read(composite.oav.snapshot)
+    yield from bps.read(composite.oav.snapshot)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     yield from bps.read(composite.webcam)
     yield from bps.save()