mx-bluesky 1.4.7__py3-none-any.whl → 1.4.8__py3-none-any.whl

mx_bluesky/hyperion/external_interaction/callbacks/snapshot_callback.py

@@ -1,4 +1,9 @@
+import dataclasses
 import re
+from collections.abc import Iterator
+from datetime import datetime
+from math import cos, radians, sin
+from pathlib import Path
 
 from dodal.devices.oav.snapshots.snapshot_image_processing import (
     compute_beam_centre_pixel_xy_for_mm_position,
@@ -10,17 +15,35 @@ from PIL import Image
 from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
     PlanReactiveCallback,
 )
-from mx_bluesky.common.parameters.constants import DocDescriptorNames
+from mx_bluesky.common.parameters.components import WithSnapshot
+from mx_bluesky.common.parameters.constants import DocDescriptorNames, PlanNameConstants
 from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER as CALLBACK_LOGGER
 
+COMPRESSION_LEVEL = 6  # 6 is the default compression level for PIL if not specified
+
+
+@dataclasses.dataclass
+class _SnapshotInfo:
+    beam_centre: tuple[int, int]
+    microns_per_pixel: tuple[float, float]
+    snapshot_path: str
+    omega: int
+    sample_pos_mm: tuple[float, float, float]
+
+    @property
+    def snapshot_basename(self) -> str:
+        match = re.match("(.*)\\.png", self.snapshot_path)
+        assert match, f"Snapshot {self.snapshot_path} was not a .png file"
+        return match.groups()[0]
+
 
 class BeamDrawingCallback(PlanReactiveCallback):
     """
     Callback that monitors for OAV_ROTATION_SNAPSHOT_TRIGGERED events and
     draws a crosshair at the beam centre, saving the snapshot to a file.
-    The callback assumes an OAV device "oav"
+    The callback assumes an OAV device "oav" and Smargon "smargon"
     Examples:
-        Take a snapshot at the current location
+        Take a rotation snapshot at the current location
     >>> from bluesky.run_engine import RunEngine
     >>> import bluesky.preprocessors as bpp
     >>> import bluesky.plan_stubs as bps
@@ -39,69 +62,198 @@ class BeamDrawingCallback(PlanReactiveCallback):
     ...         yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
     ...         yield from bps.read(oav)
     ...         yield from bps.save()
+
+        Generate rotation snapshots from a previously taken base gridscan snapshot.
+        WithSnapshot.snapshot_omegas_deg is ignored and snapshots are generated for the previously captured
+        0, 90 base images named "my_snapshot_prefix_0" and "my_snapshot_prefix_90"
+    >>> from dodal.devices.smargon import Smargon
+    >>> def take_snapshot(params: WithSnapshot, oav: OAV, smargon: Smargon, run_engine: RunEngine):
+    ...     run_engine.subscribe(BeamDrawingCallback())
+    ...     @bpp.run_decorator(md={
+    ...     "activate_callbacks": ["BeamDrawingCallback"],
+    ...         "with_snapshot": params.model_dump_json(),
+    ...     })
+    ...     def inner_plan():
+    ...         for omega in (0, 90,):
+    ...             yield from bps.abs_set(smargon.omega, omega, wait=True)
+    ...             yield from bps.abs_set(oav.grid_snapshot.directory, "/path/to/grid_snapshot_folder", wait=True)
+    ...             yield from bps.abs_set(oav.grid_snapshot.filename, f"my_grid_snapshot_prefix_{omega}", wait=True)
+    ...             yield from bps.trigger(oav.grid_snapshot, wait=True)
+    ...             yield from bps.create(DocDescriptorNames.OAV_GRID_SNAPSHOT_TRIGGERED)
+    ...             yield from bps.read(oav)        # Capture base image path
+    ...             yield from bps.read(smargon)    # Capture base image sample x, y, z, omega
+    ...             yield from bps.save()
+    ...             # Rest of gridscan here...
+    ...         # Later on...
+    ...         for omega in (0, 90,):
+    ...             yield from bps.abs_set(oav.snapshot.last_saved_path,
+    ...                 f"/path/to/snapshot_folder/my_snapshot_prefix_{omega}.png", wait=True)
+    ...             yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
+    ...             yield from bps.read(oav)            # Capture path info for generated snapshot
+    ...             yield from bps.read(smargon)        # Capture the current sample x, y, z
+    ...             yield from bps.save()
     """
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, log=CALLBACK_LOGGER, **kwargs)
-        self._snapshot_files: list[str] = []
-        self._microns_per_pixel: tuple[float, float]
-        self._beam_centre: tuple[int, int]
+        self._base_snapshots: list[_SnapshotInfo] = []
         self._rotation_snapshot_descriptor: str = ""
+        self._grid_snapshot_descriptor: str = ""
+        self._next_snapshot_info: Iterator | None = None
+        self._use_grid_snapshots: bool = False
+
+    def _reset(self):
+        self._base_snapshots = []
 
     def activity_gated_start(self, doc: RunStart):
         if self.activity_uid == doc.get("uid"):
-            with_snapshot_json = doc.get("with_snapshot")  # type: ignore
-            assert with_snapshot_json, (
-                "run start event did not have expected snapshot json"
-            )
+            self._reset()
+            with_snapshot = WithSnapshot.model_validate_json(doc.get("with_snapshot"))  # type: ignore
+            self._use_grid_snapshots = with_snapshot.use_grid_snapshots
+            CALLBACK_LOGGER.info(f"Snapshot callback initialised with {with_snapshot}")
+        elif doc.get("subplan_name") == PlanNameConstants.ROTATION_MAIN:
+            self._next_snapshot_info = None
+            CALLBACK_LOGGER.info("Snapshot callback start rotation")
         return doc
 
     def activity_gated_descriptor(self, doc: EventDescriptor) -> EventDescriptor | None:
         if doc.get("name") == DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED:
             self._rotation_snapshot_descriptor = doc["uid"]
+        elif doc.get("name") == DocDescriptorNames.OAV_GRID_SNAPSHOT_TRIGGERED:
+            self._grid_snapshot_descriptor = doc["uid"]
         return doc
 
     def activity_gated_event(self, doc: Event) -> Event:
         if doc["descriptor"] == self._rotation_snapshot_descriptor:
             self._handle_rotation_snapshot(doc)
+        elif doc["descriptor"] == self._grid_snapshot_descriptor:
+            self._handle_grid_snapshot(doc)
         return doc
 
-    def _extract_base_snapshot_params(self, doc: Event):
+    def _extract_base_snapshot_params(
+        self, snapshot_device_prefix: str, doc: Event
+    ) -> _SnapshotInfo:
         data = doc["data"]
-        self._snapshot_files.append(data["oav-snapshot-last_saved_path"])
-        self._microns_per_pixel = (
-            data["oav-microns_per_pixel_x"],
-            data["oav-microns_per_pixel_y"],
+        base_snapshot_path = data[f"oav-{snapshot_device_prefix}-last_saved_path"]
+        return _SnapshotInfo(
+            beam_centre=(data["oav-beam_centre_i"], data["oav-beam_centre_j"]),
+            microns_per_pixel=(
+                data["oav-microns_per_pixel_x"],
+                data["oav-microns_per_pixel_y"],
+            ),
+            snapshot_path=base_snapshot_path,
+            sample_pos_mm=(
+                data.get("smargon-x", 0.0),
+                data.get("smargon-y", 0.0),
+                data.get("smargon-z", 0.0),
+            ),
+            omega=round(data.get("smargon-omega", 0.0)),
         )
-        self._beam_centre = (data["oav-beam_centre_i"], data["oav-beam_centre_j"])
 
-    def _handle_rotation_snapshot(self, doc: Event):
-        self._extract_base_snapshot_params(doc)
+    def _handle_grid_snapshot(self, doc: Event):
+        snapshot_info = self._extract_base_snapshot_params("grid_snapshot", doc)
+        self._base_snapshots.append(snapshot_info)
+
+    def _handle_rotation_snapshot(self, doc: Event) -> Event:
         data = doc["data"]
-        snapshot_path = data["oav-snapshot-last_saved_path"]
-        match = re.match("(.*)\\.png", snapshot_path)
-        assert match, f"Snapshot {snapshot_path} was not a .png file"
-        snapshot_base = match.groups()[0]
-        output_snapshot_path = f"{snapshot_base}_with_beam_centre.png"
-        self._generate_snapshot_at(snapshot_path, output_snapshot_path, 0, 0)
+        if self._use_grid_snapshots:
+            if not self._next_snapshot_info:
+                self._next_snapshot_info = iter(self._base_snapshots)
+            snapshot_info = next(self._next_snapshot_info, None)
+            assert snapshot_info, (
+                "Insufficient base gridscan snapshots to generate required rotation snapshots"
+            )
+            current_sample_pos_mm = (
+                data["smargon-x"],
+                data["smargon-y"],
+                data["smargon-z"],
+            )
+            CALLBACK_LOGGER.info(
+                f"Generating snapshot at {current_sample_pos_mm} from base snapshot {snapshot_info}"
+            )
+            output_snapshot_directory = data["oav-snapshot-directory"]
+            base_file_stem = Path(snapshot_info.snapshot_path).stem
+            output_snapshot_filename = _snapshot_filename(base_file_stem)
+            output_snapshot_path = (
+                f"{output_snapshot_directory}/{output_snapshot_filename}.png"
+            )
+            self._generate_snapshot_at(
+                snapshot_info,
+                output_snapshot_path,
+                *self._image_plane_offset_mm(snapshot_info, current_sample_pos_mm),
+            )
+        else:
+            snapshot_info = self._extract_base_snapshot_params("snapshot", doc)
+            output_snapshot_path = (
+                f"{snapshot_info.snapshot_basename}_with_beam_centre.png"
+            )
+            CALLBACK_LOGGER.info(
+                f"Annotating snapshot {output_snapshot_path} from base snapshot {snapshot_info}"
+            )
+            self._generate_snapshot_zero_offset(
+                snapshot_info,
+                output_snapshot_path,
+            )
         data["oav-snapshot-last_saved_path"] = output_snapshot_path
         return doc
 
+    def _image_plane_offset_mm(
+        self,
+        snapshot_info: _SnapshotInfo,
+        current_sample_pos_mm: tuple[float, float, float],
+    ) -> tuple[float, float]:
+        return self._project_xyz_to_xy(
+            (
+                (current_sample_pos_mm[0] - snapshot_info.sample_pos_mm[0]),
+                (current_sample_pos_mm[1] - snapshot_info.sample_pos_mm[1]),
+                (current_sample_pos_mm[2] - snapshot_info.sample_pos_mm[2]),
+            ),
+            snapshot_info.omega,
+        )
+
+    def _project_xyz_to_xy(
+        self, xyz: tuple[float, float, float], omega_deg: float
+    ) -> tuple[float, float]:
+        return (
+            xyz[0],
+            xyz[1] * cos(-radians(omega_deg)) + xyz[2] * sin(-radians(omega_deg)),
+        )
+
+    def _generate_snapshot_zero_offset(
+        self,
+        base_snapshot_info: _SnapshotInfo,
+        output_snapshot_path: str,
+    ):
+        self._generate_snapshot_at(base_snapshot_info, output_snapshot_path, 0, 0)
+
     def _generate_snapshot_at(
-        self, input_snapshot_path: str, output_snapshot_path: str, x_mm: int, y_mm: int
+        self,
+        base_snapshot_info: _SnapshotInfo,
+        output_snapshot_path: str,
+        image_plane_dx_mm: float,
+        image_plane_dy_mm: float,
     ):
         """
         Save a snapshot to the specified path, with an annotated crosshair at the specified
         position
         Args:
-            input_snapshot_path: The non-annotated image path.
+            base_snapshot_info: Metadata about the base snapshot image from which the annotated
+                image will be derived.
             output_snapshot_path:  The path to the image that will be annotated.
-            x_mm: Relative x location of the sample to the original image (mm)
-            y_mm: Relative y location of the sample to the original image (mm)
+            image_plane_dx_mm: Relative x location of the sample to the original image in the image plane (mm)
+            image_plane_dy_mm: Relative y location of the sample to the original image in the image plane (mm)
         """
-        image = Image.open(input_snapshot_path)
+        image = Image.open(base_snapshot_info.snapshot_path)
         x_px, y_px = compute_beam_centre_pixel_xy_for_mm_position(
-            (x_mm, y_mm), self._beam_centre, self._microns_per_pixel
+            (image_plane_dx_mm, image_plane_dy_mm),
+            base_snapshot_info.beam_centre,
+            base_snapshot_info.microns_per_pixel,
         )
         draw_crosshair(image, x_px, y_px)
-        image.save(output_snapshot_path, format="png")
+        image.save(output_snapshot_path, format="png", compress_level=COMPRESSION_LEVEL)
+
+
+def _snapshot_filename(grid_snapshot_name):
+    time_now = datetime.now()
+    filename = f"{time_now.strftime('%H%M%S%f')[:8]}_oav_snapshot_{grid_snapshot_name}"
+    return filename

mx_bluesky/hyperion/parameters/cli.py

@@ -9,7 +9,6 @@ from mx_bluesky._version import version
 class HyperionArgs:
     dev_mode: bool = False
     verbose_event_logging: bool = False
-    skip_startup_connection: bool = False
 
 
 def _add_callback_relevant_args(parser: argparse.ArgumentParser) -> None:
@@ -17,7 +16,7 @@ def _add_callback_relevant_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--dev",
         action="store_true",
-        help="Use dev options, such as local graylog instances and S03",
+        help="Use dev options, such as local graylog instances",
     )
 
 
@@ -32,8 +31,7 @@ def parse_callback_dev_mode_arg() -> bool:
 def parse_cli_args() -> HyperionArgs:
     """Parses all arguments relevant to hyperion. Returns an HyperionArgs dataclass with
     the fields: (verbose_event_logging: bool,
-                 dev_mode: bool,
-                 skip_startup_connection: bool)"""
+                 dev_mode: bool)"""
     parser = argparse.ArgumentParser()
     _add_callback_relevant_args(parser)
     parser.add_argument(
@@ -41,11 +39,6 @@ def parse_cli_args() -> HyperionArgs:
         action="store_true",
         help="Log all bluesky event documents to graylog",
     )
-    parser.add_argument(
-        "--skip-startup-connection",
-        action="store_true",
-        help="Skip connecting to EPICS PVs on startup",
-    )
     parser.add_argument(
         "--version",
         help="Print hyperion version string",
@@ -56,5 +49,4 @@ def parse_cli_args() -> HyperionArgs:
     return HyperionArgs(
         verbose_event_logging=args.verbose_event_logging or False,
         dev_mode=args.dev or False,
-        skip_startup_connection=args.skip_startup_connection or False,
     )

mx_bluesky/hyperion/parameters/constants.py

@@ -12,8 +12,6 @@ from mx_bluesky.common.parameters.constants import (
     OavConstants,
     PlanGroupCheckpointConstants,
     PlanNameConstants,
-    SimConstants,
-    TriggerConstants,
 )
 
 TEST_MODE = os.environ.get("HYPERION_TEST_MODE")
@@ -42,15 +40,12 @@ class I03Constants:
 @dataclass(frozen=True)
 class HyperionConstants:
     DESCRIPTORS = DocDescriptorNames()
-    TRIGGER = TriggerConstants()
     ZOCALO_ENV = EnvironmentConstants.ZOCALO_ENV
     HARDWARE = HardwareConstants()
     I03 = I03Constants()
     PARAM = ExperimentParamConstants()
     PLAN = PlanNameConstants()
     WAIT = PlanGroupCheckpointConstants()
-    SIM = SimConstants()
-    TRIGGER = TriggerConstants()
     CALLBACK_0MQ_PROXY_PORTS = (5577, 5578)
     DESCRIPTORS = DocDescriptorNames()
     CONFIG_SERVER_URL = (

mx_bluesky/hyperion/parameters/device_composites.py

@@ -6,13 +6,17 @@ from dodal.devices.aperturescatterguard import (
 )
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
-from dodal.devices.dcm import DCM
+from dodal.devices.common_dcm import BaseDCM
+from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.fast_grid_scan import (
     PandAFastGridScan,
     ZebraFastGridScan,
 )
 from dodal.devices.flux import Flux
+from dodal.devices.i03 import Beamstop
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import Smargon
@@ -24,22 +28,53 @@ from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
 from dodal.devices.zocalo import ZocaloResults
 from ophyd_async.fastcs.panda import HDFPanda
 
+from mx_bluesky.common.plans.common_flyscan_xray_centre_plan import (
+    FlyScanEssentialDevices,
+)
+
 
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
-class HyperionFlyScanXRayCentreComposite:
+class HyperionFlyScanXRayCentreComposite(FlyScanEssentialDevices):
     """All devices which are directly or indirectly required by this plan"""
 
     aperture_scatterguard: ApertureScatterguard
     attenuator: BinaryFilterAttenuator
+    dcm: BaseDCM
+    eiger: EigerDetector
+    flux: Flux
+    s4_slit_gaps: S4SlitGaps
+    undulator: Undulator
+    synchrotron: Synchrotron
+    zebra: Zebra
+    zocalo: ZocaloResults
+    panda: HDFPanda
+    panda_fast_grid_scan: PandAFastGridScan
+    robot: BartRobot
+    sample_shutter: ZebraShutter
     backlight: Backlight
-    dcm: DCM
+    xbpm_feedback: XBPMFeedback
+    zebra_fast_grid_scan: ZebraFastGridScan
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class GridDetectThenXRayCentreComposite:
+    """All devices which are directly or indirectly required by this plan"""
+
+    aperture_scatterguard: ApertureScatterguard
+    attenuator: BinaryFilterAttenuator
+    backlight: Backlight
+    beamstop: Beamstop
+    dcm: BaseDCM
+    detector_motion: DetectorMotion
     eiger: EigerDetector
     zebra_fast_grid_scan: ZebraFastGridScan
     flux: Flux
-    s4_slit_gaps: S4SlitGaps
+    oav: OAV
+    pin_tip_detection: PinTipDetection
     smargon: Smargon
-    undulator: Undulator
     synchrotron: Synchrotron
+    s4_slit_gaps: S4SlitGaps
+    undulator: Undulator
     xbpm_feedback: XBPMFeedback
     zebra: Zebra
     zocalo: ZocaloResults

mx_bluesky/hyperion/parameters/gridscan.py

@@ -1,8 +1,5 @@
 from __future__ import annotations
 
-from dodal.devices.detector import (
-    DetectorParams,
-)
 from dodal.devices.fast_grid_scan import (
     PandAGridScanParams,
     ZebraGridScanParams,
@@ -13,7 +10,6 @@ from mx_bluesky.common.parameters.gridscan import (
     SpecifiedThreeDGridScan,
 )
 from mx_bluesky.hyperion.parameters.components import WithHyperionUDCFeatures
-from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 
 
 class GridCommonWithHyperionDetectorParams(GridCommon, WithHyperionUDCFeatures):
@@ -23,34 +19,11 @@ class GridCommonWithHyperionDetectorParams(GridCommon, WithHyperionUDCFeatures):
     # https://github.com/DiamondLightSource/hyperion/issues/1395"""
     @property
     def detector_params(self):
-        self.det_dist_to_beam_converter_path = (
-            self.det_dist_to_beam_converter_path
-            or CONST.PARAM.DETECTOR.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=I03Constants.DETECTOR,
-            expected_energy_ev=self.demand_energy_ev,
-            exposure_time_s=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,
-            enable_dev_shm=self.features.compare_cpu_and_gpu_zocalo
-            or self.features.use_gpu_results,
-            **optional_args,
+        params = super().detector_params
+        params.enable_dev_shm = (
+            self.features.compare_cpu_and_gpu_zocalo or self.features.use_gpu_results
         )
+        return params
 
 
 class HyperionSpecifiedThreeDGridScan(WithHyperionUDCFeatures, SpecifiedThreeDGridScan):
@@ -58,36 +31,14 @@ class HyperionSpecifiedThreeDGridScan(WithHyperionUDCFeatures, SpecifiedThreeDGr
 
     # These detector params only exist so that we can properly select enable_dev_shm. Remove in
     # https://github.com/DiamondLightSource/hyperion/issues/1395"""
+
     @property
     def detector_params(self):
-        self.det_dist_to_beam_converter_path = (
-            self.det_dist_to_beam_converter_path
-            or CONST.PARAM.DETECTOR.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=I03Constants.DETECTOR,
-            expected_energy_ev=self.demand_energy_ev,
-            exposure_time_s=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,
-            enable_dev_shm=self.features.compare_cpu_and_gpu_zocalo
-            or self.features.use_gpu_results,
-            **optional_args,
+        params = super().detector_params
+        params.enable_dev_shm = (
+            self.features.compare_cpu_and_gpu_zocalo or self.features.use_gpu_results
         )
+        return params
 
     # Relative to common grid scan, stub offsets are defined by config server
     @property

mx_bluesky/hyperion/parameters/rotation.py

@@ -192,7 +192,3 @@ class MultiRotationScan(RotationExperiment, SplitScan):
             self._num_images_per_scan()[0],
             len(self._num_images_per_scan()),
         )
-
-    @property
-    def ispyb_params(self):  # pyright: ignore
-        raise ValueError("Please get ispyb params from one of the individual scans")

mx_bluesky/hyperion/utils/context.py

@@ -5,14 +5,11 @@ import mx_bluesky.hyperion.experiment_plans as hyperion_plans
 from mx_bluesky.common.utils.log import LOGGER
 
 
-def setup_context(wait_for_connection: bool = True) -> BlueskyContext:
+def setup_context() -> BlueskyContext:
     context = BlueskyContext()
     context.with_plan_module(hyperion_plans)
 
-    context.with_dodal_module(
-        get_beamline_based_on_environment_variable(),
-        wait_for_connection=wait_for_connection,
-    )
+    context.with_dodal_module(get_beamline_based_on_environment_variable())
 
     LOGGER.info(f"Plans found in context: {context.plan_functions.keys()}")
 

mx_bluesky/hyperion/utils/validation.py

@@ -21,7 +21,7 @@ from mx_bluesky.hyperion.external_interaction.callbacks.rotation.nexus_callback
     RotationNexusFileCallback,
 )
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.rotation import RotationScan
+from mx_bluesky.hyperion.parameters.rotation import MultiRotationScan
 
 DISPLAY_CONFIGURATION = "tests/test_data/test_display.configuration"
 ZOOM_LEVELS_XML = "tests/test_data/test_jCameraManZoomLevels.xml"
@@ -36,33 +36,36 @@ def test_params(filename_stub, dir):
         with open(filename) as f:
             return json.loads(f.read())
 
-    params = RotationScan(
+    params = MultiRotationScan(
         **get_params(
-            "tests/test_data/parameter_json_files/good_test_rotation_scan_parameters.json"
+            "tests/test_data/parameter_json_files/good_test_one_multi_rotation_scan_parameters.json"
         )
     )
+    for scan_params in params.rotation_scans:
+        scan_params.x_start_um = 0
+        scan_params.y_start_um = 0
+        scan_params.z_start_um = 0
+        scan_params.scan_width_deg = 360
     params.file_name = filename_stub
-    params.scan_width_deg = 360
     params.demand_energy_ev = 12700
     params.storage_directory = str(dir)
-    params.x_start_um = 0
-    params.y_start_um = 0
-    params.z_start_um = 0
     params.exposure_time_s = 0.004
     return params
 
 
 def fake_rotation_scan(
-    parameters: RotationScan,
+    parameters: MultiRotationScan,
     subscription: RotationNexusFileCallback,
     rotation_devices: RotationScanComposite,
 ):
+    single_scan_parameters = next(parameters.single_rotation_scans)
+
     @bpp.subs_decorator(subscription)
     @bpp.set_run_key_decorator("rotation_scan_with_cleanup_and_subs")
     @bpp.run_decorator(  # attach experiment metadata to the start document
         md={
             "subplan_name": CONST.PLAN.ROTATION_OUTER,
-            "mx_bluesky_parameters": parameters.model_dump_json(),
+            "mx_bluesky_parameters": single_scan_parameters.model_dump_json(),
             "activate_callbacks": "RotationNexusFileCallback",
         }
     )
@@ -129,7 +132,7 @@ def fake_create_rotation_devices():
 
 
 def sim_rotation_scan_to_create_nexus(
-    test_params: RotationScan,
+    test_params: MultiRotationScan,
     fake_create_rotation_devices: RotationScanComposite,
     filename_stub,
     RE,

{mx_bluesky-1.4.7.dist-info → mx_bluesky-1.4.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mx-bluesky
-Version: 1.4.7
+Version: 1.4.8
 Summary: Bluesky tools for MX Beamlines at DLS
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License
@@ -236,10 +236,10 @@ Requires-Dist: semver
 Requires-Dist: matplotlib
 Requires-Dist: blueapi>=0.5.0
 Requires-Dist: daq-config-server>=0.1.1
-Requires-Dist: ophyd==1.9.0
-Requires-Dist: ophyd-async>=0.9.0a2
+Requires-Dist: ophyd>=1.10.5
+Requires-Dist: ophyd-async>=0.10.0a2
 Requires-Dist: bluesky>=1.13.1
-Requires-Dist: dls-dodal==1.44.0
+Requires-Dist: dls-dodal==1.47.0
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -257,6 +257,7 @@ Requires-Dist: pyright; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-random-order; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: sphinx-autobuild; extra == "dev"