mx-bluesky 1.5.14__py3-none-any.whl → 1.5.16__py3-none-any.whl

mx_bluesky/common/preprocessors/preprocessors.py

@@ -1,3 +1,6 @@
+from collections.abc import Callable
+
+import bluesky.plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.preprocessors import plan_mutator
 from bluesky.utils import Msg, MsgGenerator, make_decorator
@@ -12,15 +15,61 @@ from mx_bluesky.common.protocols.protocols import (
 )
 
 
-def transmission_and_xbpm_feedback_for_collection_wrapper(
+def _create_insert_plans_mutator(
+    run_key_to_wrap: PlanNameConstants | None = None,
+    on_open: Callable[[Msg], MsgGenerator] | None = None,
+    on_close: Callable[[], MsgGenerator] | None = None,
+) -> Callable[[Msg], tuple[MsgGenerator | None, MsgGenerator | None]]:
+    """
+    Inserts plans to be executed when the run with the given name opens/closes.
+
+    Args:
+        run_key_to_wrap: The run name to insert before/after. If None (default) then
+            insert on the first open/close run regardless of its name.
+        on_open: The plan to perform just before the run opens
+        on_close: The plan to perform just after the run closes
+
+    """
+    _wrapped_run_name: None | str = None
+
+    def insert_plans(msg: Msg):
+        # Wrap the specified run, or, if none specified, wrap the first run encountered
+        nonlocal _wrapped_run_name
+
+        match msg.command:
+            case "open_run":
+                # If we specified a run key, did we encounter it
+                # If we didn't specify, then insert the plans and track the name of the run
+                if on_open is not None and (
+                    not (run_key_to_wrap or _wrapped_run_name)
+                    or run_key_to_wrap is msg.run
+                ):
+                    _wrapped_run_name = msg.run if msg.run else "unnamed_run"
+                    return on_open(msg), None
+            case "close_run":
+                # Check if the run tracked from above was closed
+                # An exception is raised in the RunEngine if two unnamed runs are opened
+                # at the same time, so we are safe from unpausing on the wrong run
+                if on_close is not None and (
+                    (_wrapped_run_name == "unnamed_run" and not msg.run)
+                    or (msg.run and _wrapped_run_name and _wrapped_run_name is msg.run)
+                ):
+                    return None, on_close()
+
+        return None, None
+
+    return insert_plans
+
+
+def pause_xbpm_feedback_during_collection_at_desired_transmission_wrapper(
     plan: MsgGenerator,
     devices: XBPMPauseDevices,
     desired_transmission_fraction: float,
     run_key_to_wrap: PlanNameConstants | None = None,
 ):
     """
-    Sets the transmission for the data collection, ensuring the xbpm feedback is valid, then resets it immediately after
-    the run has finished.
+    Sets the transmission for the data collection, ensuring the xbpm feedback is valid, then pauses
+     XBPM feedback. Resets transmission and unpauses XBPM immediately after the run has finished.
 
     This wrapper should be attached to the entry point of any beamline-specific plan that may disrupt the XBPM feedback,
     such as a data collection or an x-ray center grid scan.
@@ -38,15 +87,13 @@ def transmission_and_xbpm_feedback_for_collection_wrapper(
     Args:
         plan: The plan performing the data collection.
         devices (XBPMPauseDevices): Composite device including The XBPM device that is responsible for keeping
-                                                        the beam in position, and attenuator
+            the beam in position, and attenuator
         desired_transmission_fraction (float): The desired transmission for the collection
-        run_key_to_wrap: (str | None): Pausing XBPM and setting transmission is inserted after the 'open_run' message is seen with
-        the matching run key, and unpausing and resetting transmission is inserted after the corresponding 'close_run' message is
-        seen. If not specified, instead wrap the first run encountered.
+        run_key_to_wrap: (str | None): Pausing XBPM and setting transmission is inserted before the 'open_run' message is seen with
+            the matching run key, and unpausing and resetting transmission is inserted after the corresponding 'close_run' message is
+            seen. If not specified, instead wrap the first run encountered.
     """
 
-    _wrapped_run_name: None | str = None
-
     def head(msg: Msg):
         yield from check_and_pause_feedback(
             devices.xbpm_feedback,
@@ -62,36 +109,13 @@ def transmission_and_xbpm_feedback_for_collection_wrapper(
             devices.xbpm_feedback, devices.attenuator
         )
 
-    def insert_plans(msg: Msg):
-        # Wrap the specified run, or, if none specified, wrap the first run encountered
-        nonlocal _wrapped_run_name
-
-        match msg.command:
-            case "open_run":
-                # If we specified a run key, did we encounter it
-                # If we didn't specify, then insert the plans and track the name of the run
-                if (
-                    not (run_key_to_wrap or _wrapped_run_name)
-                    or run_key_to_wrap is msg.run
-                ):
-                    _wrapped_run_name = msg.run if msg.run else "unnamed_run"
-                    return head(msg), None
-            case "close_run":
-                # Check if the run tracked from above was closed
-                # An exception is raised in the RunEngine if two unnamed runs are opened
-                # at the same time, so we are safe from unpausing on the wrong run
-                if (_wrapped_run_name == "unnamed_run" and not msg.run) or (
-                    msg.run and _wrapped_run_name and _wrapped_run_name is msg.run
-                ):
-                    return None, tail()
-
-        return None, None
+    mutator = _create_insert_plans_mutator(run_key_to_wrap, head, tail)
 
     # Contingency wrapper can cause unpausing to occur on exception and again on close_run.
     # Not needed after https://github.com/bluesky/bluesky/issues/1891
     return (
         yield from bpp.contingency_wrapper(
-            plan_mutator(plan, insert_plans),
+            plan_mutator(plan, mutator),
             except_plan=lambda _: unpause_xbpm_feedback_and_set_transmission_to_1(
                 devices.xbpm_feedback,
                 devices.attenuator,
@@ -100,6 +124,44 @@ def transmission_and_xbpm_feedback_for_collection_wrapper(
     )
 
 
-transmission_and_xbpm_feedback_for_collection_decorator = make_decorator(
-    transmission_and_xbpm_feedback_for_collection_wrapper
+def set_transmission_and_trigger_xbpm_feedback_before_collection_wrapper(
+    plan: MsgGenerator,
+    devices: XBPMPauseDevices,
+    desired_transmission_fraction: float,
+    run_key_to_wrap: PlanNameConstants | None = None,
+):
+    """
+    Sets the transmission and triggers xbpm feedback immediately before
+    doing the specified run. Doesn't revert transmission at the end of the plan.
+
+    Args:
+        plan: The plan performing the data collection.
+        devices (XBPMPauseDevices): Composite device including The XBPM device that is responsible for keeping
+            the beam in position, and the attenuator
+        desired_transmission_fraction (float): The desired transmission for the collection
+        run_key_to_wrap: (str | None): 'Set transmission' and 'trigger XBPM device' is inserted before the 'open_run' message with
+            the matching run key is seen. If not specified, instead wrap the first run encountered.
+    """
+
+    def head(msg: Msg):
+        yield from bps.mv(devices.attenuator, desired_transmission_fraction)
+        yield from bps.trigger(devices.xbpm_feedback)
+
+        # Allow 'open_run' message to pass through
+        yield msg
+
+    mutator = _create_insert_plans_mutator(run_key_to_wrap, head)
+
+    return (yield from plan_mutator(plan, mutator))
+
+
+set_transmission_and_trigger_xbpm_feedback_before_collection_decorator = make_decorator(
+    set_transmission_and_trigger_xbpm_feedback_before_collection_wrapper
+)
+
+
+pause_xbpm_feedback_during_collection_at_desired_transmission_decorator = (
+    make_decorator(
+        pause_xbpm_feedback_during_collection_at_desired_transmission_wrapper
+    )
 )

mx_bluesky/hyperion/__main__.py

@@ -2,9 +2,11 @@ import json
 import signal
 import threading
 from dataclasses import asdict
+from pathlib import Path
 from sys import argv
 from traceback import format_exception
 
+from blueapi.config import ApplicationConfig, ConfigLoader
 from blueapi.core import BlueskyContext
 from flask import Flask, request
 from flask_restful import Api, Resource
@@ -28,6 +30,7 @@ from mx_bluesky.hyperion.external_interaction.agamemnon import (
     compare_params,
     update_params_from_agamemnon,
 )
+from mx_bluesky.hyperion.in_process_runner import InProcessRunner
 from mx_bluesky.hyperion.parameters.cli import (
     HyperionArgs,
     HyperionMode,
@@ -42,6 +45,7 @@ from mx_bluesky.hyperion.runner import (
     StatusAndMessage,
     make_error_status_and_message,
 )
+from mx_bluesky.hyperion.supervisor import SupervisorRunner
 from mx_bluesky.hyperion.utils.context import setup_context
 
 
@@ -152,7 +156,11 @@ def create_app(runner: GDARunner, test_config=None) -> Flask:
 def initialise_globals(args: HyperionArgs):
     """Do all early main low-level application initialisation."""
     do_default_logging_setup(
-        CONST.LOG_FILE_NAME, CONST.GRAYLOG_PORT, dev_mode=args.dev_mode
+        CONST.SUPERVISOR_LOG_FILE_NAME
+        if args.mode == HyperionMode.SUPERVISOR
+        else CONST.LOG_FILE_NAME,
+        CONST.GRAYLOG_PORT,
+        dev_mode=args.dev_mode,
     )
     LOGGER.info(f"Hyperion launched with args:{argv}")
     alerting.set_alerting_service(LoggingAlertService(CONST.GRAYLOG_STREAM_ID))
@@ -163,27 +171,52 @@ def main():
     args = parse_cli_args()
     initialise_globals(args)
     hyperion_port = HyperionConstants.HYPERION_PORT
-    context = setup_context(dev_mode=args.dev_mode)
-
-    if args.mode == HyperionMode.GDA:
-        runner = GDARunner(context=context)
-        app = create_app(runner)
-        flask_thread = threading.Thread(
-            target=lambda: app.run(
-                host="0.0.0.0", port=hyperion_port, debug=True, use_reloader=False
-            ),
-            daemon=True,
-        )
-        flask_thread.start()
-        LOGGER.info(
-            f"Hyperion now listening on {hyperion_port} ({'IN DEV' if args.dev_mode else ''})"
-        )
-        runner.wait_on_queue()
-    else:
-        plan_runner = PlanRunner(context, args.dev_mode)
-        create_server_for_udc(plan_runner)
-        _register_sigterm_handler(plan_runner)
-        run_forever(plan_runner)
+
+    match args.mode:
+        case HyperionMode.GDA:
+            context = setup_context(dev_mode=args.dev_mode)
+            runner = GDARunner(context=context)
+            app = create_app(runner)
+            flask_thread = threading.Thread(
+                target=lambda: app.run(
+                    host="0.0.0.0", port=hyperion_port, debug=True, use_reloader=False
+                ),
+                daemon=True,
+            )
+            flask_thread.start()
+            LOGGER.info(
+                f"Hyperion now listening on {hyperion_port} ({'IN DEV' if args.dev_mode else ''})"
+            )
+            runner.wait_on_queue()
+        case HyperionMode.UDC:
+            context = setup_context(dev_mode=args.dev_mode)
+            plan_runner = InProcessRunner(context, args.dev_mode)
+            create_server_for_udc(plan_runner, HyperionConstants.HYPERION_PORT)
+            _register_sigterm_handler(plan_runner)
+            run_forever(plan_runner)
+        case HyperionMode.SUPERVISOR:
+            if not args.client_config:
+                raise RuntimeError(
+                    "BlueAPI client configuration file must be specified in supervisor mode."
+                )
+            if not args.supervisor_config:
+                raise RuntimeError(
+                    "BlueAPI supervisor configuration file must be specified in supervisor mode."
+                )
+
+            client_config = _load_config_from_yaml(Path(args.client_config))
+            supervisor_config = _load_config_from_yaml(Path(args.supervisor_config))
+            context = BlueskyContext(configuration=supervisor_config)
+            plan_runner = SupervisorRunner(context, client_config, args.dev_mode)
+            create_server_for_udc(plan_runner, HyperionConstants.SUPERVISOR_PORT)
+            _register_sigterm_handler(plan_runner)
+            run_forever(plan_runner)
+
+
+def _load_config_from_yaml(config_path: Path):
+    loader = ConfigLoader(ApplicationConfig)
+    loader.use_values_from_yaml(config_path)
+    return loader.load()
 
 
 def _register_sigterm_handler(runner: PlanRunner):

mx_bluesky/hyperion/baton_handler.py

@@ -1,45 +1,30 @@
 from collections.abc import Sequence
-from functools import partial
-from typing import Any
 
 from blueapi.core.context import BlueskyContext
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import MsgGenerator, RunEngineInterrupted
 from dodal.common.beamlines.commissioning_mode import set_commissioning_signal
-from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.baton import Baton
-from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
-from dodal.devices.motors import XYZStage
-from dodal.devices.robot import BartRobot
-from dodal.devices.smargon import Smargon
 
-from mx_bluesky.common.device_setup_plans.robot_load_unload import robot_unload
 from mx_bluesky.common.external_interaction.alerting import (
     AlertService,
     get_alerting_service,
 )
-from mx_bluesky.common.parameters.components import MxBlueskyParameters
+from mx_bluesky.common.parameters.components import (
+    MxBlueskyParameters,
+    get_param_version,
+)
 from mx_bluesky.common.utils.context import (
-    device_composite_from_context,
     find_device_in_context,
 )
 from mx_bluesky.common.utils.exceptions import BeamlineCheckFailureError
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
-    create_devices,
-    load_centre_collect_full,
-)
-from mx_bluesky.hyperion.experiment_plans.udc_default_state import (
-    UDCDefaultDevices,
-    move_to_udc_default_state,
-)
 from mx_bluesky.hyperion.external_interaction.agamemnon import (
     create_parameters_from_agamemnon,
 )
 from mx_bluesky.hyperion.external_interaction.alerting.constants import Subjects
-from mx_bluesky.hyperion.parameters.components import Wait
-from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+from mx_bluesky.hyperion.parameters.components import UDCCleanup, UDCDefaultState
 from mx_bluesky.hyperion.plan_runner import PlanError, PlanRunner
 from mx_bluesky.hyperion.utils.context import (
     clear_all_device_caches,
@@ -102,7 +87,14 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
         """
         _raise_udc_start_alert(get_alerting_service())
         yield from bpp.contingency_wrapper(
-            _move_to_udc_default_state(context),
+            runner.decode_and_execute(
+                None,
+                [
+                    UDCDefaultState.model_validate(
+                        {"parameter_model_version": get_param_version()}
+                    )
+                ],
+            ),
             except_plan=trap_default_state_exception,
             auto_raise=False,
         )
@@ -115,7 +107,14 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
                 baton, runner, current_visit
             )
         if current_visit:
-            yield from _clean_up_udc(runner.context, current_visit)
+            yield from runner.decode_and_execute(
+                current_visit,
+                [
+                    UDCCleanup.model_validate(
+                        {"parameter_model_version": get_param_version()}
+                    )
+                ],
+            )
 
     def release_baton() -> MsgGenerator:
         # If hyperion has given up the baton itself we need to also release requested
@@ -177,23 +176,9 @@ def _fetch_and_process_agamemnon_instruction(
 ) -> MsgGenerator[str | None]:
     parameter_list: Sequence[MxBlueskyParameters] = create_parameters_from_agamemnon()
     if parameter_list:
-        for parameters in parameter_list:
-            LOGGER.info(
-                f"Executing plan with parameters: {parameters.model_dump_json(indent=2)}"
-            )
-            match parameters:
-                case LoadCentreCollect():
-                    current_visit = parameters.visit
-                    devices: Any = create_devices(runner.context)
-                    yield from runner.execute_plan(
-                        partial(load_centre_collect_full, devices, parameters)
-                    )
-                case Wait():
-                    yield from runner.execute_plan(partial(_runner_sleep, parameters))
-                case _:
-                    raise AssertionError(
-                        f"Unsupported instruction decoded from agamemnon {type(parameters)}"
-                    )
+        current_visit = yield from runner.decode_and_execute(
+            current_visit, parameter_list
+        )
     else:
         _raise_udc_completed_alert(get_alerting_service())
         # Release the baton for orderly exit from the instruction loop
@@ -224,20 +209,11 @@ def _raise_udc_completed_alert(alert_service: AlertService):
     )
 
 
-def _runner_sleep(parameters: Wait) -> MsgGenerator:
-    yield from bps.sleep(parameters.duration_s)
-
-
 def _is_requesting_baton(baton: Baton) -> MsgGenerator:
     requested_user = yield from bps.rd(baton.requested_user)
     return requested_user == HYPERION_USER
 
 
-def _move_to_udc_default_state(context: BlueskyContext):
-    udc_default_devices = device_composite_from_context(context, UDCDefaultDevices)
-    yield from move_to_udc_default_state(udc_default_devices)
-
-
 def _get_baton(context: BlueskyContext) -> Baton:
     return find_device_in_context(context, "baton", Baton)
 
@@ -255,19 +231,3 @@ def _unrequest_baton(baton: Baton) -> MsgGenerator[str]:
         yield from bps.abs_set(baton.requested_user, NO_USER)
         return NO_USER
     return requested_user
-
-
-def _clean_up_udc(context: BlueskyContext, visit: str) -> MsgGenerator:
-    cleanup_group = "cleanup"
-    robot = find_device_in_context(context, "robot", BartRobot)
-    smargon = find_device_in_context(context, "smargon", Smargon)
-    aperture_scatterguard = find_device_in_context(
-        context, "aperture_scatterguard", ApertureScatterguard
-    )
-    lower_gonio = find_device_in_context(context, "lower_gonio", XYZStage)
-    detector_motion = find_device_in_context(context, "detector_motion", DetectorMotion)
-    yield from bps.abs_set(
-        detector_motion.shutter, ShutterState.CLOSED, group=cleanup_group
-    )
-    yield from robot_unload(robot, smargon, aperture_scatterguard, lower_gonio, visit)
-    yield from bps.wait(cleanup_group)

mx_bluesky/hyperion/blueapi_config.yaml

@@ -0,0 +1,17 @@
+env:
+  sources:
+    - kind: deviceManager
+      module: dodal.beamlines.i03
+    - kind: planFunctions
+      module: mx_bluesky.hyperion.blueapi_plans
+  events:
+    broadcast_status_events: false
+api:
+  url: http://localhost:5005
+stomp:
+  enabled: true
+  url: tcp://localhost:61613
+logging:
+  graylog:
+    url: "tcp://graylog-log-target.diamond.ac.uk:12232"
+    enabled: true

mx_bluesky/hyperion/blueapi_dev_config.yaml

@@ -0,0 +1,16 @@
+env:
+  sources:
+    - kind: deviceManager
+      module: dodal.beamlines.i03
+      mock: true
+    - kind: planFunctions
+      module: mx_bluesky.hyperion.blueapi_plans
+  events:
+    broadcast_status_events: false
+api:
+  url: http://localhost:5005
+stomp:
+  enabled: true
+  url: tcp://localhost:61613
+logging:
+  level: DEBUG

mx_bluesky/hyperion/blueapi_plans/__init__.py

@@ -0,0 +1,96 @@
+"""
+This module contains the bluesky plan entry points for use with hyperion-blueapi.
+The json schema and documentation therein generated by the blueapi /plans endpoint
+from this file constitutes the hyperion-blueapi interface to the hyperion supervisor
+process.
+"""
+
+from bluesky import plan_stubs as bps
+from bluesky.utils import MsgGenerator
+from dodal.common import inject
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
+from dodal.devices.motors import XYZStage
+from dodal.devices.robot import BartRobot
+from dodal.devices.smargon import Smargon
+
+from mx_bluesky.common.device_setup_plans.robot_load_unload import (
+    robot_unload as _robot_unload,
+)
+from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
+    LoadCentreCollectComposite,
+)
+from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
+    load_centre_collect_full as _load_centre_collect_full,
+)
+from mx_bluesky.hyperion.experiment_plans.udc_default_state import (
+    UDCDefaultDevices,
+)
+from mx_bluesky.hyperion.experiment_plans.udc_default_state import (
+    move_to_udc_default_state as _move_to_udc_default_state,
+)
+from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+
+__all__ = [
+    "LoadCentreCollectComposite",
+    "LoadCentreCollect",
+    "UDCDefaultDevices",
+    "clean_up_udc",
+    "load_centre_collect",
+    "move_to_udc_default_state",
+    "robot_unload",
+]
+
+
+def load_centre_collect(
+    parameters: LoadCentreCollect, composite: LoadCentreCollectComposite = inject()
+) -> MsgGenerator:
+    """
+    Attempt a complete data collection experiment, consisting of the following:
+        * Load the sample if necessary
+        * Move to the specified goniometer start angles
+        * Perform optical centring, then X-ray centring
+        * If X-ray centring finds one or more diffracting centres then for each centre
+    that satisfies the chosen selection function,
+    move to that centre and do a collection with the specified parameters.
+    """
+    yield from _load_centre_collect_full(composite, parameters)
+
+
+def robot_unload(
+    visit: str,
+    robot: BartRobot = inject("robot"),
+    smargon: Smargon = inject("smargon"),
+    aperture_scatterguard: ApertureScatterguard = inject("aperture_scatterguard"),
+    lower_gonio: XYZStage = inject("lower_gonio"),
+) -> MsgGenerator:
+    """
+    Unload the currently mounted pin into the location that it was loaded from.
+    This is to be invoked as the final step upon successful completion of the UDC queue.
+    """
+    yield from _robot_unload(robot, smargon, aperture_scatterguard, lower_gonio, visit)
+
+
+def clean_up_udc(
+    visit: str,
+    cleanup_group: str = "cleanup",
+    robot: BartRobot = inject("robot"),
+    smargon: Smargon = inject("smargon"),
+    aperture_scatterguard: ApertureScatterguard = inject("aperture_scatterguard"),
+    lower_gonio: XYZStage = inject("lower_gonio"),
+    detector_motion: DetectorMotion = inject("detector_motion"),
+) -> MsgGenerator:
+    yield from bps.abs_set(
+        detector_motion.shutter, ShutterState.CLOSED, group=cleanup_group
+    )
+    yield from _robot_unload(robot, smargon, aperture_scatterguard, lower_gonio, visit)
+    yield from bps.wait(cleanup_group)
+
+
+def move_to_udc_default_state(
+    composite: UDCDefaultDevices = inject(),
+) -> MsgGenerator:
+    """
+    Move beamline hardware to known positions prior to UDC start.
+    """
+    yield from _move_to_udc_default_state(composite)

mx_bluesky/hyperion/device_setup_plans/dcm_pitch_roll_mirror_adjuster.py

@@ -1,5 +1,3 @@
-import json
-
 import bluesky.plan_stubs as bps
 from dodal.devices.focusing_mirror import (
     FocusingMirrorWithStripes,
@@ -17,6 +15,9 @@ from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.utils.utils import (
     energy_to_bragg_angle,
 )
+from mx_bluesky.hyperion.external_interaction.config_server import (
+    get_hyperion_config_client,
+)
 
 MIRROR_VOLTAGE_GROUP = "MIRROR_VOLTAGE_GROUP"
 DCM_GROUP = "DCM_GROUP"
@@ -27,11 +28,12 @@ def _apply_and_wait_for_voltages_to_settle(
     stripe: MirrorStripe,
     mirror_voltages: MirrorVoltages,
 ):
-    with open(mirror_voltages.voltage_lookup_table_path) as lut_file:
-        json_obj = json.load(lut_file)
-
+    config_server = get_hyperion_config_client()
+    config_dict = config_server.get_file_contents(
+        mirror_voltages.voltage_lookup_table_path, dict
+    )
     # sample mode is the only mode supported
-    sample_data = json_obj["sample"]
+    sample_data = config_dict["sample"]
     if stripe == MirrorStripe.BARE:
         stripe_key = "bare"
     elif stripe == MirrorStripe.RHODIUM:

mx_bluesky/hyperion/device_setup_plans/setup_panda.py

@@ -16,8 +16,8 @@ from ophyd_async.fastcs.panda import (
 )
 
 from mx_bluesky.common.device_setup_plans.setup_panda import load_panda_from_yaml
+from mx_bluesky.common.parameters.constants import DeviceSettingsConstants
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.parameters.constants import DeviceSettingsConstants
 
 MM_TO_ENCODER_COUNTS = 200000
 GENERAL_TIMEOUT = 60

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -4,6 +4,9 @@ from collections.abc import Callable
 from typing import TypedDict
 
 import mx_bluesky.hyperion.experiment_plans.rotation_scan_plan as rotation_scan_plan
+from mx_bluesky.common.parameters.rotation import (
+    RotationScan,
+)
 from mx_bluesky.hyperion.experiment_plans import (
     hyperion_grid_detect_then_xray_centre_plan,
     load_centre_collect_full_plan,
@@ -15,7 +18,6 @@ from mx_bluesky.hyperion.parameters.gridscan import (
     PinTipCentreThenXrayCentre,
 )
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
-from mx_bluesky.hyperion.parameters.rotation import RotationScan
 
 
 def not_implemented():

mx_bluesky/hyperion/experiment_plans/hyperion_flyscan_xray_centre_plan.py

@@ -49,11 +49,8 @@ def construct_hyperion_specific_features(
     signals_to_read_pre_flyscan = [
         xrc_composite.undulator.current_gap,
         xrc_composite.synchrotron.synchrotron_mode,
-        xrc_composite.s4_slit_gaps.xgap,
-        xrc_composite.s4_slit_gaps.ygap,
-        xrc_composite.smargon.x,
-        xrc_composite.smargon.y,
-        xrc_composite.smargon.z,
+        xrc_composite.s4_slit_gaps,
+        xrc_composite.smargon,
         xrc_composite.dcm.energy_in_keV,
     ]
 
@@ -64,6 +61,8 @@ def construct_hyperion_specific_features(
         xrc_composite.dcm.energy_in_keV,
         xrc_composite.eiger.bit_depth,
         xrc_composite.beamsize,
+        xrc_composite.eiger.cam.roi_mode,
+        xrc_composite.eiger.ispyb_detector_id,
     ]
 
     setup_trigger_plan: Callable[..., MsgGenerator]

mx_bluesky/hyperion/experiment_plans/hyperion_grid_detect_then_xray_centre_plan.py

@@ -11,7 +11,7 @@ from mx_bluesky.common.experiment_plans.common_grid_detect_then_xray_centre_plan
 )
 from mx_bluesky.common.parameters.constants import OavConstants, PlanNameConstants
 from mx_bluesky.common.preprocessors.preprocessors import (
-    transmission_and_xbpm_feedback_for_collection_decorator,
+    pause_xbpm_feedback_during_collection_at_desired_transmission_decorator,
 )
 from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.hyperion.experiment_plans.hyperion_flyscan_xray_centre_plan import (
@@ -45,7 +45,7 @@ def hyperion_grid_detect_then_xray_centre(
     """
 
     @verify_undulator_gap_before_run_decorator(composite)
-    @transmission_and_xbpm_feedback_for_collection_decorator(
+    @pause_xbpm_feedback_during_collection_at_desired_transmission_decorator(
         composite, parameters.transmission_frac, PlanNameConstants.GRIDSCAN_OUTER
     )
     def plan_to_perform():