mx-bluesky 1.5.2__py3-none-any.whl → 1.5.3__py3-none-any.whl

mx_bluesky/hyperion/__main__.py

@@ -1,33 +1,24 @@
-import atexit
 import json
 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
 
 from blueapi.core import BlueskyContext
-from bluesky.callbacks.zmq import Publisher
-from bluesky.run_engine import RunEngine
-from bluesky.utils import MsgGenerator
 from flask import Flask, request
 from flask_restful import Api, Resource
-from pydantic.dataclasses import dataclass
 
-from mx_bluesky.common.external_interaction.callbacks.common.log_uid_tag_callback import (
-    LogUidTaggingCallback,
+from mx_bluesky.common.external_interaction import alerting
+from mx_bluesky.common.external_interaction.alerting.log_based_service import (
+    LoggingAlertService,
 )
-from mx_bluesky.common.parameters.components import MxBlueskyParameters
 from mx_bluesky.common.parameters.constants import Actions, Status
-from mx_bluesky.common.utils.exceptions import WarningException
 from mx_bluesky.common.utils.log import (
     LOGGER,
     do_default_logging_setup,
     flush_debug_handler,
 )
-from mx_bluesky.common.utils.tracing import TRACER
+from mx_bluesky.hyperion.baton_handler import run_forever
 from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     PLAN_REGISTRY,
     PlanNotFound,
@@ -36,143 +27,22 @@ from mx_bluesky.hyperion.external_interaction.agamemnon import (
     compare_params,
     update_params_from_agamemnon,
 )
-from mx_bluesky.hyperion.parameters.cli import parse_cli_args
+from mx_bluesky.hyperion.parameters.cli import (
+    HyperionArgs,
+    HyperionMode,
+    parse_cli_args,
+)
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+from mx_bluesky.hyperion.plan_runner import PlanRunner
+from mx_bluesky.hyperion.runner import (
+    GDARunner,
+    StatusAndMessage,
+    make_error_status_and_message,
+)
 from mx_bluesky.hyperion.utils.context import setup_context
 
 
-@dataclass
-class Command:
-    action: Actions
-    devices: Any | None = None
-    experiment: Callable[[Any, Any], MsgGenerator] | None = None
-    parameters: MxBlueskyParameters | None = None
-
-
-@dataclass
-class StatusAndMessage:
-    status: str
-    message: str = ""
-
-    def __init__(self, status: Status, message: str = "") -> None:
-        self.status = status.value
-        self.message = message
-
-
-@dataclass
-class ErrorStatusAndMessage(StatusAndMessage):
-    exception_type: str = ""
-
-
-def make_error_status_and_message(exception: Exception):
-    return ErrorStatusAndMessage(
-        status=Status.FAILED.value,
-        message=repr(exception),
-        exception_type=type(exception).__name__,
-    )
-
-
-class BlueskyRunner:
-    def __init__(
-        self,
-        RE: RunEngine,
-        context: BlueskyContext,
-    ) -> None:
-        self.command_queue: Queue[Command] = Queue()
-        self.current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
-        self.last_run_aborted: bool = False
-        self.logging_uid_tag_callback = LogUidTaggingCallback()
-        self.context: BlueskyContext
-
-        self.RE = RE
-        self.context = context
-        RE.subscribe(self.logging_uid_tag_callback)
-
-        LOGGER.info("Connecting to external callback ZMQ proxy...")
-        self.publisher = Publisher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[0]}")
-        RE.subscribe(self.publisher)
-
-    def start(
-        self,
-        experiment: Callable,
-        parameters: MxBlueskyParameters,
-        plan_name: str,
-    ) -> StatusAndMessage:
-        LOGGER.info(f"Started with parameters: {parameters.model_dump_json(indent=2)}")
-
-        devices: Any = PLAN_REGISTRY[plan_name]["setup"](self.context)
-
-        if (
-            self.current_status.status == Status.BUSY.value
-            or self.current_status.status == Status.ABORTING.value
-        ):
-            return StatusAndMessage(Status.FAILED, "Bluesky already running")
-        else:
-            self.current_status = StatusAndMessage(Status.BUSY)
-            self.command_queue.put(
-                Command(
-                    action=Actions.START,
-                    devices=devices,
-                    experiment=experiment,
-                    parameters=parameters,
-                )
-            )
-            return StatusAndMessage(Status.SUCCESS)
-
-    def stopping_thread(self):
-        try:
-            self.RE.abort()
-            self.current_status = StatusAndMessage(Status.IDLE)
-        except Exception as e:
-            self.current_status = make_error_status_and_message(e)
-
-    def stop(self) -> StatusAndMessage:
-        if self.current_status.status == Status.IDLE.value:
-            return StatusAndMessage(Status.FAILED, "Bluesky not running")
-        elif self.current_status.status == Status.ABORTING.value:
-            return StatusAndMessage(Status.FAILED, "Bluesky already stopping")
-        else:
-            self.current_status = StatusAndMessage(Status.ABORTING)
-            stopping_thread = threading.Thread(target=self.stopping_thread)
-            stopping_thread.start()
-            self.last_run_aborted = True
-            return StatusAndMessage(Status.ABORTING)
-
-    def shutdown(self):
-        """Stops the run engine and the loop waiting for messages."""
-        print("Shutting down: Stopping the run engine gracefully")
-        self.stop()
-        self.command_queue.put(Command(action=Actions.SHUTDOWN))
-
-    def wait_on_queue(self):
-        while True:
-            command = self.command_queue.get()
-            if command.action == Actions.SHUTDOWN:
-                return
-            elif command.action == Actions.START:
-                if command.experiment is None:
-                    raise ValueError("No experiment provided for START")
-                try:
-                    with TRACER.start_span("do_run"):
-                        self.RE(command.experiment(command.devices, command.parameters))
-
-                    self.current_status = StatusAndMessage(Status.IDLE)
-
-                    self.last_run_aborted = False
-                except WarningException as exception:
-                    LOGGER.warning("Warning Exception", exc_info=True)
-                    self.current_status = make_error_status_and_message(exception)
-                except Exception as exception:
-                    LOGGER.error("Exception on running plan", exc_info=True)
-
-                    if self.last_run_aborted:
-                        # Aborting will cause an exception here that we want to swallow
-                        self.last_run_aborted = False
-                    else:
-                        self.current_status = make_error_status_and_message(exception)
-
-
 def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions):
     experiment_registry_entry = PLAN_REGISTRY.get(plan_name)
     if experiment_registry_entry is None:
@@ -203,7 +73,7 @@ def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions)
 
 
 class RunExperiment(Resource):
-    def __init__(self, runner: BlueskyRunner, context: BlueskyContext) -> None:
+    def __init__(self, runner: GDARunner, context: BlueskyContext) -> None:
         super().__init__()
         self.runner = runner
         self.context = context
@@ -228,9 +98,9 @@ class RunExperiment(Resource):
 
 
 class StopOrStatus(Resource):
-    def __init__(self, runner: BlueskyRunner) -> None:
+    def __init__(self, runner: GDARunner) -> None:
         super().__init__()
-        self.runner: BlueskyRunner = runner
+        self.runner: GDARunner = runner
 
     def put(self, action):
         status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
@@ -252,8 +122,9 @@ class StopOrStatus(Resource):
 class FlushLogs(Resource):
     def put(self, **kwargs):
         try:
+            log_file = flush_debug_handler()
             status_and_message = StatusAndMessage(
-                Status.SUCCESS, f"Flushed debug log to {flush_debug_handler()}"
+                Status.SUCCESS, f"Flushed debug log to {log_file}"
             )
         except Exception as e:
             status_and_message = StatusAndMessage(
@@ -262,25 +133,18 @@ class FlushLogs(Resource):
         return asdict(status_and_message)
 
 
-def create_app(
-    test_config=None,
-    RE: RunEngine = RunEngine({}),
-    dev_mode: bool = False,
-) -> tuple[Flask, BlueskyRunner]:
-    context = setup_context(dev_mode=dev_mode)
-    runner = BlueskyRunner(
-        RE,
-        context=context,
-    )
+def create_app(runner: GDARunner, test_config=None) -> Flask:
     app = Flask(__name__)
     if test_config:
         app.config.update(test_config)
     api = Api(app)
+
     api.add_resource(
         RunExperiment,
         "/<string:plan_name>/<string:action>",
-        resource_class_args=[runner, context],
+        resource_class_args=[runner, runner.context],
     )
+
     api.add_resource(
         FlushLogs,
         "/flush_debug_log",
@@ -290,33 +154,41 @@ def create_app(
         "/<string:action>",
         resource_class_args=[runner],
     )
-    return app, runner
+    return app
 
 
-def create_targets():
-    hyperion_port = 5005
-    args = parse_cli_args()
+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
     )
     LOGGER.info(f"Hyperion launched with args:{argv}")
-    app, runner = create_app(dev_mode=args.dev_mode)
-    return app, runner, hyperion_port, args.dev_mode
+    alerting.set_alerting_service(LoggingAlertService(CONST.GRAYLOG_STREAM_ID))
 
 
 def main():
-    app, runner, port, dev_mode = create_targets()
-    atexit.register(runner.shutdown)
-    flask_thread = threading.Thread(
-        target=lambda: app.run(
-            host="0.0.0.0", port=port, debug=True, use_reloader=False
-        ),
-        daemon=True,
-    )
-    flask_thread.start()
-    LOGGER.info(f"Hyperion now listening on {port} ({'IN DEV' if dev_mode else ''})")
-    runner.wait_on_queue()
-    flask_thread.join()
+    """Main application entry point."""
+    args = parse_cli_args()
+    initialise_globals(args)
+    hyperion_port = 5005
+    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:
+        run_forever(PlanRunner(context))
 
 
 if __name__ == "__main__":

mx_bluesky/hyperion/baton_handler.py

@@ -1,22 +1,28 @@
 from collections.abc import Sequence
+from functools import partial
+from typing import Any
 
-from blueapi.core import BlueskyContext
+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.devices.baton import Baton
 
-from mx_bluesky.common.utils.context import find_device_in_context
-from mx_bluesky.common.utils.exceptions import WarningException
+from mx_bluesky.common.parameters.components import MxBlueskyParameters
+from mx_bluesky.common.utils.context import (
+    find_device_in_context,
+)
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
-    LoadCentreCollectComposite,
     create_devices,
     load_centre_collect_full,
 )
 from mx_bluesky.hyperion.external_interaction.agamemnon import (
     create_parameters_from_agamemnon,
 )
+from mx_bluesky.hyperion.parameters.components import Wait
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+from mx_bluesky.hyperion.plan_runner import PlanException, PlanRunner
 from mx_bluesky.hyperion.utils.context import (
     clear_all_device_caches,
     setup_devices,
@@ -26,48 +32,78 @@ HYPERION_USER = "Hyperion"
 NO_USER = "None"
 
 
-def wait_for_hyperion_requested(baton: Baton):
-    SLEEP_PER_CHECK = 0.1
-    while True:
-        requested_user = yield from bps.rd(baton.requested_user)
-        if requested_user == HYPERION_USER:
-            break
-        yield from bps.sleep(SLEEP_PER_CHECK)
+def run_forever(runner: PlanRunner):
+    try:
+        while True:
+            try:
+                run_udc_when_requested(runner.context, runner)
+            except PlanException as e:
+                LOGGER.info(
+                    "Caught exception during plan execution, stopped and waiting for baton.",
+                    exc_info=e,
+                )
+
+    except RunEngineInterrupted:
+        # In the event that BlueskyRunner.stop() or shutdown() was called then
+        # RunEngine.abort() will have been called and we will get RunEngineInterrupted
+        LOGGER.info(
+            f"RunEngine was interrupted. Runner state is {runner.current_status}, "
+            f"run engine is {runner.RE.state}"
+        )
 
 
-def ignore_sample_errors(exception: Exception):
-    yield from bps.null()
-    # For sample errors we want to continue the loop
-    if not isinstance(exception, WarningException):
-        raise exception
+def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
+    """This will wait for the baton to be handed to hyperion and then run through the
+    UDC queue from agamemnon until:
+      1. There are no more instructions from agamemnon
+      2. There is an error on the beamline
+      3. The baton is requested by another party
+      4. A shutdown is requested
+
+    In the case of 1. 2. or 4. hyperion will immediately release the baton. In the case of
+    3. the baton will be released after the next collection has finished."""
 
+    baton = _get_baton(context)
 
-def main_hyperion_loop(baton: Baton, composite: LoadCentreCollectComposite):
-    requested_user = yield from bps.rd(baton.requested_user)
-    while requested_user == HYPERION_USER:
+    def acquire_baton() -> MsgGenerator:
+        yield from _wait_for_hyperion_requested(baton)
+        yield from bps.abs_set(baton.current_user, HYPERION_USER)
+
+    def collect() -> MsgGenerator:
+        """
+        Move to the default state for collection, then enter a loop fetching instructions
+        from Agamemnon and continue the loop until any of the following occur:
+        * A user requests the baton away from Hyperion
+        * Hyperion releases the baton when Agamemnon has no more instructions
+        * The RunEngine raises a RequestAbort exception, most likely due to a shutdown command
+        * A plan raises an exception not of type WarningException (which is then wrapped as a PlanException)
+        Args:
+            baton: The baton device
+            runner: The runner
+        """
+        yield from _move_to_default_state()
 
-        def inner_loop():
-            parameter_list: Sequence[LoadCentreCollect] = (
-                create_parameters_from_agamemnon()
-            )
-            if parameter_list:
-                for parameters in parameter_list:
-                    yield from load_centre_collect_full(composite, parameters)
-            else:
-                yield from bps.mv(baton.requested_user, NO_USER)
-
-        yield from bpp.contingency_wrapper(
-            inner_loop(), except_plan=ignore_sample_errors, auto_raise=False
-        )
-        requested_user = yield from bps.rd(baton.requested_user)
+        # re-fetch the baton because the device has been reinstantiated
+        baton = _get_baton(context)
+        while (yield from _is_requesting_baton(baton)):
+            yield from _fetch_and_process_agamemnon_instruction(baton, runner)
 
+    def release_baton() -> MsgGenerator:
+        # If hyperion has given up the baton itself we need to also release requested
+        # user so that hyperion doesn't think we're requested again
+        baton = _get_baton(context)
+        yield from _safely_release_baton(baton)
+        yield from bps.abs_set(baton.current_user, NO_USER)
 
-def move_to_default_state():
-    # To be filled in in https://github.com/DiamondLightSource/mx-bluesky/issues/396
-    yield from bps.null()
+    def collect_then_release() -> MsgGenerator:
+        yield from bpp.contingency_wrapper(collect(), final_plan=release_baton)
+
+    context.run_engine(acquire_baton())
+    _initialise_udc(context)
+    context.run_engine(collect_then_release())
 
 
-def initialise_udc(context: BlueskyContext, dev_mode: bool = False):
+def _initialise_udc(context: BlueskyContext):
     """
     Perform all initialisation that happens at the start of UDC just after the
     baton is acquired, but before we execute any plans or move hardware.
@@ -77,45 +113,65 @@ def initialise_udc(context: BlueskyContext, dev_mode: bool = False):
     """
     LOGGER.info("Initialising mx-bluesky for UDC start...")
     clear_all_device_caches(context)
-    setup_devices(context, dev_mode)
+    setup_devices(context, False)
 
 
-def _get_baton(context: BlueskyContext) -> Baton:
-    return find_device_in_context(context, "baton", Baton)
+def _wait_for_hyperion_requested(baton: Baton):
+    SLEEP_PER_CHECK = 0.1
+    while True:
+        requested_user = yield from bps.rd(baton.requested_user)
+        if requested_user == HYPERION_USER:
+            break
+        yield from bps.sleep(SLEEP_PER_CHECK)
 
 
-def run_udc_when_requested(context: BlueskyContext, dev_mode: bool = False):
-    """This will wait for the baton to be handed to hyperion and then run through the
-    UDC queue from agamemnon until:
-      1. There are no more instructions from agamemnon
-      2. There is an error on the beamline
-      3. The baton is requested by another party
+def _fetch_and_process_agamemnon_instruction(
+    baton: Baton, runner: PlanRunner
+) -> MsgGenerator:
+    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():
+                    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)}"
+                    )
+    else:
+        # Release the baton for orderly exit from the instruction loop
+        yield from _safely_release_baton(baton)
+
+
+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
 
-    In the case of 1. or 2. hyperion will immediately release the baton. In the case of
-    3. the baton will be released after the next collection has finished."""
 
-    baton = _get_baton(context)
-    yield from wait_for_hyperion_requested(baton)
-    yield from bps.abs_set(baton.current_user, HYPERION_USER)
+def _move_to_default_state() -> MsgGenerator:
+    # To be filled in in https://github.com/DiamondLightSource/mx-bluesky/issues/396
+    yield from bps.null()
 
-    def initialise_then_collect():
-        initialise_udc(context, dev_mode)
-        yield from move_to_default_state()
 
-        # re-fetch the baton because the device has been reinstantiated
-        new_baton = _get_baton(context)
-        composite = create_devices(context)
-        yield from main_hyperion_loop(new_baton, composite)
+def _get_baton(context: BlueskyContext) -> Baton:
+    return find_device_in_context(context, "baton", Baton)
 
-    def release_baton():
-        # If hyperion has given up the baton itself we need to also release requested
-        # user so that hyperion doesn't think we're requested again
-        baton = _get_baton(context)
-        requested_user = yield from bps.rd(baton.requested_user)
-        if requested_user == HYPERION_USER:
-            yield from bps.abs_set(baton.requested_user, NO_USER)
-        yield from bps.abs_set(baton.current_user, NO_USER)
 
-    yield from bpp.contingency_wrapper(
-        initialise_then_collect(), final_plan=release_baton
-    )
+def _safely_release_baton(baton: Baton) -> MsgGenerator:
+    """Relinquish the requested user of the baton if it is not already requested
+    by another user."""
+    requested_user = yield from bps.rd(baton.requested_user)
+    if requested_user == HYPERION_USER:
+        yield from bps.abs_set(baton.requested_user, NO_USER)

mx_bluesky/hyperion/device_setup_plans/dcm_pitch_roll_mirror_adjuster.py

@@ -59,31 +59,41 @@ def _apply_and_wait_for_voltages_to_settle(
 def adjust_mirror_stripe(
     energy_kev, mirror: FocusingMirrorWithStripes, mirror_voltages: MirrorVoltages
 ):
-    """Feedback should be OFF prior to entry, in order to prevent
+    """Adjusts the mirror stripe based on the new energy.
+
+    Changing this takes some time and moves motors that are liable to overheating so we
+    check whether its required first.
+
+    Feedback should be OFF prior to entry, in order to prevent
     feedback from making unnecessary corrections while beam is being adjusted."""
     mirror_config = mirror.energy_to_stripe(energy_kev)
 
-    LOGGER.info(
-        f"Adjusting mirror stripe for {energy_kev}keV selecting {mirror_config['stripe']} stripe"
-    )
-    yield from bps.abs_set(mirror.stripe, mirror_config["stripe"], wait=True)
-    yield from bps.trigger(mirror.apply_stripe)
+    current_mirror_stripe = yield from bps.rd(mirror.stripe)
+    new_stripe = mirror_config["stripe"]
 
-    # yaw, lat cannot be done simultaneously
-    LOGGER.info(f"Adjusting {mirror.name} lat to {mirror_config['lat_mm']}")
-    yield from bps.abs_set(
-        mirror.x_mm, mirror_config["lat_mm"], wait=True, timeout=YAW_LAT_TIMEOUT_S
-    )
+    if current_mirror_stripe != new_stripe:
+        LOGGER.info(
+            f"Adjusting mirror stripe for {energy_kev}keV selecting {new_stripe} stripe"
+        )
+        yield from bps.abs_set(mirror.stripe, new_stripe, wait=True)
+        yield from bps.trigger(mirror.apply_stripe)
 
-    LOGGER.info(f"Adjusting {mirror.name} yaw to {mirror_config['yaw_mrad']}")
-    yield from bps.abs_set(
-        mirror.yaw_mrad, mirror_config["yaw_mrad"], wait=True, timeout=YAW_LAT_TIMEOUT_S
-    )
+        # yaw, lat cannot be done simultaneously
+        LOGGER.info(f"Adjusting {mirror.name} lat to {mirror_config['lat_mm']}")
+        yield from bps.abs_set(
+            mirror.x_mm, mirror_config["lat_mm"], wait=True, timeout=YAW_LAT_TIMEOUT_S
+        )
 
-    LOGGER.info("Adjusting mirror voltages...")
-    yield from _apply_and_wait_for_voltages_to_settle(
-        mirror_config["stripe"], mirror_voltages
-    )
+        LOGGER.info(f"Adjusting {mirror.name} yaw to {mirror_config['yaw_mrad']}")
+        yield from bps.abs_set(
+            mirror.yaw_mrad,
+            mirror_config["yaw_mrad"],
+            wait=True,
+            timeout=YAW_LAT_TIMEOUT_S,
+        )
+
+        LOGGER.info("Adjusting mirror voltages...")
+        yield from _apply_and_wait_for_voltages_to_settle(new_stripe, mirror_voltages)
 
 
 def adjust_dcm_pitch_roll_vfm_from_lut(
@@ -128,9 +138,4 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
     yield from dcm_roll_adjuster(DCM_GROUP)
     LOGGER.info("Waiting for DCM roll adjust to complete...")
 
-    #
-    # Adjust vfm mirror stripe and mirror voltages
-    #
-
-    # VFM Stripe selection
     yield from adjust_mirror_stripe(energy_kev, vfm, mirror_voltages)

mx_bluesky/hyperion/experiment_plans/hyperion_flyscan_xray_centre_plan.py

@@ -22,6 +22,9 @@ from mx_bluesky.hyperion.device_setup_plans.setup_panda import (
 from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
     setup_zebra_for_panda_flyscan,
 )
+from mx_bluesky.hyperion.external_interaction.config_server import (
+    get_hyperion_config_client,
+)
 from mx_bluesky.hyperion.parameters.device_composites import (
     HyperionFlyScanXRayCentreComposite,
 )
@@ -64,7 +67,7 @@ def construct_hyperion_specific_features(
 
     setup_trigger_plan: Callable[..., MsgGenerator]
 
-    if xrc_parameters.features.use_panda_for_gridscan:
+    if get_hyperion_config_client().get_feature_flags().USE_PANDA_FOR_GRIDSCAN:
         setup_trigger_plan = _panda_triggering_setup
         tidy_plan = partial(_panda_tidy, xrc_composite)
         set_flyscan_params_plan = partial(