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

mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -24,7 +24,10 @@ from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
     RotationScanComposite,
     rotation_scan_internal,
 )
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.external_interaction.config_server import (
+    get_hyperion_config_client,
+)
+from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 from mx_bluesky.hyperion.parameters.rotation import RotationScanPerSweep
 
@@ -51,7 +54,8 @@ def load_centre_collect_full(
     * If X-ray centring finds a diffracting centre then move to that centre and
     * do a collection with the specified parameters.
     """
-    parameters.features.update_self_from_server()
+
+    get_hyperion_config_client().refresh_cache()
 
     if not oav_params:
         oav_params = OAVParameters(context="xrayCentring")
@@ -60,8 +64,16 @@ def load_centre_collect_full(
     @set_run_key_decorator(CONST.PLAN.LOAD_CENTRE_COLLECT)
     @run_decorator(
         md={
-            "metadata": {"sample_id": parameters.sample_id},
-            "activate_callbacks": ["BeamDrawingCallback", "SampleHandlingCallback"],
+            "metadata": {
+                "sample_id": parameters.sample_id,
+                "visit": parameters.visit,
+                "container": parameters.sample_puck,
+            },
+            "activate_callbacks": [
+                "BeamDrawingCallback",
+                "SampleHandlingCallback",
+                "AlertOnContainerChange",
+            ],
             "with_snapshot": parameters.multi_rotation_scan.model_dump_json(
                 include=WithSnapshot.model_fields.keys()  # type: ignore
             ),
@@ -117,7 +129,7 @@ def load_centre_collect_full(
 
         multi_rotation.rotation_scans.clear()
 
-        is_alternating = parameters.features.alternate_rotation_direction
+        is_alternating = I03Constants.ALTERNATE_ROTATION_DIRECTION
 
         generator = rotation_scan_generator(is_alternating)
         next(generator)

mx_bluesky/hyperion/experiment_plans/pin_tip_centring_plan.py

@@ -155,7 +155,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)
 
     # need to wait for the OAV image to update
     # See #673 for improvements

mx_bluesky/hyperion/experiment_plans/robot_load_and_change_energy.py

@@ -12,7 +12,7 @@ from blueapi.core import BlueskyContext
 from bluesky.utils import Msg
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
-from dodal.devices.backlight import Backlight, BacklightPosition
+from dodal.devices.backlight import Backlight, InOut
 from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, MirrorVoltages
 from dodal.devices.i03.dcm import DCM
 from dodal.devices.i03.undulator_dcm import UndulatorDCM
@@ -123,7 +123,11 @@ def robot_load_and_snapshots(
     thawing_time: float,
     demand_energy_ev: float | None,
 ):
-    yield from bps.abs_set(composite.backlight, BacklightPosition.IN, group="snapshot")
+    yield from bps.abs_set(composite.backlight, InOut.IN, group="snapshot")
+
+    yield from bps.create(name=CONST.DESCRIPTORS.ROBOT_PRE_LOAD)
+    yield from bps.read(composite.robot)
+    yield from bps.save()
 
     robot_load_plan = do_robot_load(
         composite,

mx_bluesky/hyperion/experiment_plans/rotation_scan_plan.py

@@ -58,7 +58,7 @@ from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
     setup_zebra_for_rotation,
     tidy_up_zebra_after_rotation_scan,
 )
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 from mx_bluesky.hyperion.parameters.rotation import (
     RotationScan,
     SingleRotationScan,
@@ -133,7 +133,7 @@ def calculate_motion_profile(
     direction = params.rotation_direction
     start_scan_deg = params.omega_start_deg
 
-    if params.features.omega_flip:
+    if I03Constants.OMEGA_FLIP:
         # If omega_flip is True then the motor omega axis is inverted with respect to the
         # hyperion coordinate system.
         start_scan_deg = -start_scan_deg
@@ -386,7 +386,6 @@ def rotation_scan_internal(
     parameters: RotationScan,
     oav_params: OAVParameters | None = None,
 ) -> MsgGenerator:
-    parameters.features.update_self_from_server()
     if not oav_params:
         oav_params = OAVParameters(context="xrayCentring")
     eiger: EigerDetector = composite.eiger

mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -3,6 +3,7 @@ import json
 import re
 import traceback
 from collections.abc import Sequence
+from enum import StrEnum
 from os import path
 from typing import Any, TypeVar
 
@@ -14,6 +15,7 @@ from pydantic_extra_types.semantic_version import SemanticVersion
 
 from mx_bluesky.common.parameters.components import (
     PARAMETER_VERSION,
+    MxBlueskyParameters,
     WithVisit,
 )
 from mx_bluesky.common.parameters.constants import (
@@ -21,6 +23,7 @@ from mx_bluesky.common.parameters.constants import (
 )
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.utils.utils import convert_angstrom_to_eV
+from mx_bluesky.hyperion.parameters.components import Wait
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 
 T = TypeVar("T", bound=WithVisit)
@@ -31,8 +34,13 @@ MULTIPIN_REGEX = rf"^{MULTIPIN_PREFIX}_(\d+)x(\d+(?:\.\d+)?)\+(\d+(?:\.\d+)?)$"
 MX_GENERAL_ROOT_REGEX = r"^/dls/(?P<beamline>[^/]+)/data/[^/]*/(?P<visit>[^/]+)(?:/|$)"
 
 
+class _InstructionType(StrEnum):
+    WAIT = "wait"
+    COLLECT = "collect"
+
+
 @dataclasses.dataclass
-class PinType:
+class _PinType:
     expected_number_of_crystals: int
     single_well_width_um: float
     tip_to_first_well_um: float = 0
@@ -54,7 +62,7 @@ class PinType:
         )
 
 
-class SinglePin(PinType):
+class _SinglePin(_PinType):
     def __init__(self):
         super().__init__(1, GridscanParamConstants.WIDTH_UM)
 
@@ -63,23 +71,115 @@ class SinglePin(PinType):
         return self.single_well_width_um
 
 
+def create_parameters_from_agamemnon() -> Sequence[MxBlueskyParameters]:
+    """Fetch the next instruction from agamemnon and convert it into one or more
+    mx-bluesky instructions.
+    Returns:
+        The generated sequence of mx-bluesky parameters, or empty list if
+        no instructions."""
+    beamline_name = get_beamline_name("i03")
+    agamemnon_instruction = _get_next_instruction(beamline_name)
+    if agamemnon_instruction:
+        match _instruction_and_data(agamemnon_instruction):
+            case (_InstructionType.COLLECT, data):
+                return _populate_parameters_from_agamemnon(data)
+            case (_InstructionType.WAIT, data):
+                return [
+                    Wait.model_validate(
+                        {
+                            "duration_s": data,
+                            "parameter_model_version": _get_param_version(),
+                        }
+                    )
+                ]
+
+    return []
+
+
+def compare_params(load_centre_collect_params: LoadCentreCollect):
+    """Compare the supplied parameters (as supplied from GDA) with those directly
+    created from agamemnon. Any differences are logged.
+    Args:
+        load_centre_collect_params: The parameters from GDA to compare."""
+    try:
+        lcc_requests = create_parameters_from_agamemnon()
+        # Log differences against GDA populated parameters
+        if not lcc_requests:
+            LOGGER.info("Agamemnon returned no instructions")
+        else:
+            differences = DeepDiff(
+                lcc_requests[0], load_centre_collect_params, math_epsilon=1e-5
+            )
+            if differences:
+                LOGGER.info(
+                    f"Different parameters found when directly reading from Hyperion: {differences}"
+                )
+    except (ValueError, KeyError):
+        LOGGER.warning(f"Failed to compare parameters: {traceback.format_exc()}")
+    except Exception:
+        LOGGER.warning(
+            f"Unexpected error occurred. Failed to compare parameters: {traceback.format_exc()}"
+        )
+
+
+def update_params_from_agamemnon(parameters: T) -> T:
+    """Update the supplied parameters with additional information from agamemnon.
+    This is currently necessary for multipin processing and called when Hyperion is invoked
+    from GDA.
+
+    Args:
+        parameters: The LoadCentreCollectParameters that will be updated with additional info,
+        such as multipin dimensions, number of crystals.
+    """
+    try:
+        beamline_name = get_beamline_name("i03")
+        agamemnon_params = _get_next_instruction(beamline_name)
+        instruction, collect_params = _instruction_and_data(agamemnon_params)
+        assert instruction == _InstructionType.COLLECT, (
+            "Unable to augment GDA parameters from agamemnon, agamemnon reports 'wait'"
+        )
+        pin_type = _get_pin_type_from_agamemnon_collect_parameters(collect_params)
+        if isinstance(parameters, LoadCentreCollect):
+            parameters.robot_load_then_centre.tip_offset_um = pin_type.full_width / 2
+            parameters.robot_load_then_centre.grid_width_um = pin_type.full_width
+            parameters.select_centres.n = pin_type.expected_number_of_crystals
+            if pin_type != _SinglePin():
+                # Rotation snapshots will be generated from the gridscan snapshots,
+                # no need to specify snapshot omega.
+                parameters.multi_rotation_scan.snapshot_omegas_deg = []
+                parameters.multi_rotation_scan.use_grid_snapshots = True
+    except (ValueError, ValidationError) as e:
+        LOGGER.warning(f"Failed to update parameters: {e}")
+    except Exception as e:
+        LOGGER.warning(f"Unexpected error occurred. Failed to update parameters: {e}")
+
+    return parameters
+
+
+def _instruction_and_data(agamemnon_instruction: dict) -> tuple[str, Any]:
+    instruction, data = next(iter(agamemnon_instruction.items()))
+    if instruction not in _InstructionType.__members__.values():
+        raise KeyError(
+            f"Unexpected instruction from agamemnon: {agamemnon_instruction}"
+        )
+    return instruction, data
+
+
 def _get_parameters_from_url(url: str) -> dict:
     response = requests.get(url, headers={"Accept": "application/json"})
     response.raise_for_status()
-    response_json = json.loads(response.content)
-    try:
-        return response_json["collect"]
-    except KeyError as e:
-        raise KeyError(f"Unexpected json from agamemnon: {response_json}") from e
+    return json.loads(response.content)
 
 
-def get_pin_type_from_agamemnon_parameters(parameters: dict) -> PinType:
-    loop_type_name: str | None = parameters["sample"]["loopType"]
+def _get_pin_type_from_agamemnon_collect_parameters(
+    collect_parameters: dict,
+) -> _PinType:
+    loop_type_name: str | None = collect_parameters["sample"]["loopType"]
     if loop_type_name:
         regex_search = re.search(MULTIPIN_REGEX, loop_type_name)
         if regex_search:
             wells, well_size, tip_to_first_well = regex_search.groups()
-            return PinType(int(wells), float(well_size), float(tip_to_first_well))
+            return _PinType(int(wells), float(well_size), float(tip_to_first_well))
         else:
             loop_type_message = (
                 f"Agamemnon loop type of {loop_type_name} not recognised"
@@ -87,14 +187,14 @@ def get_pin_type_from_agamemnon_parameters(parameters: dict) -> PinType:
             if loop_type_name.startswith(MULTIPIN_PREFIX):
                 raise ValueError(f"{loop_type_message}. {MULTIPIN_FORMAT_DESC}")
             LOGGER.warning(f"{loop_type_message}, assuming single pin")
-    return SinglePin()
+    return _SinglePin()
 
 
-def get_next_instruction(beamline: str) -> dict:
+def _get_next_instruction(beamline: str) -> dict:
     return _get_parameters_from_url(AGAMEMNON_URL + f"getnextcollect/{beamline}")
 
 
-def get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
+def _get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
     try:
         prefix = parameters["prefix"]
         collection = parameters["collection"]
@@ -113,7 +213,7 @@ def get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
     )
 
 
-def get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
+def _get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
     try:
         first_collection: dict = parameters["collection"][0]
         wavelength = first_collection.get("wavelength")
@@ -124,21 +224,29 @@ def get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]
         return {"demand_energy_ev": None}
 
 
-def get_param_version() -> SemanticVersion:
+def _get_param_version() -> SemanticVersion:
     return SemanticVersion.validate_from_str(str(PARAMETER_VERSION))
 
 
-def populate_parameters_from_agamemnon(agamemnon_params) -> Sequence[LoadCentreCollect]:
-    visit, detector_distance = get_withvisit_parameters_from_agamemnon(agamemnon_params)
-    with_energy_params = get_withenergy_parameters_from_agamemnon(agamemnon_params)
-    pin_type = get_pin_type_from_agamemnon_parameters(agamemnon_params)
+def _populate_parameters_from_agamemnon(
+    agamemnon_params,
+) -> Sequence[LoadCentreCollect]:
+    if not agamemnon_params:
+        # Empty dict means no instructions
+        return []
+
+    visit, detector_distance = _get_withvisit_parameters_from_agamemnon(
+        agamemnon_params
+    )
+    with_energy_params = _get_withenergy_parameters_from_agamemnon(agamemnon_params)
+    pin_type = _get_pin_type_from_agamemnon_collect_parameters(agamemnon_params)
     collections = agamemnon_params["collection"]
     visit_directory, file_name = path.split(agamemnon_params["prefix"])
 
     return [
         LoadCentreCollect.model_validate(
             {
-                "parameter_model_version": get_param_version(),
+                "parameter_model_version": _get_param_version(),
                 "visit": visit,
                 "detector_distance_mm": detector_distance,
                 "sample_id": agamemnon_params["sample"]["id"],
@@ -148,7 +256,6 @@ def populate_parameters_from_agamemnon(agamemnon_params) -> Sequence[LoadCentreC
                     "name": "TopNByMaxCount",
                     "n": pin_type.expected_number_of_crystals,
                 },
-                "features": {"use_gpu_results": True},
                 "robot_load_then_centre": {
                     "storage_directory": str(visit_directory) + "/xraycentring",
                     "file_name": file_name,
@@ -186,55 +293,3 @@ def populate_parameters_from_agamemnon(agamemnon_params) -> Sequence[LoadCentreC
         )
         for collection in collections
     ]
-
-
-def create_parameters_from_agamemnon() -> Sequence[LoadCentreCollect]:
-    beamline_name = get_beamline_name("i03")
-    agamemnon_params = get_next_instruction(beamline_name)
-    return (
-        populate_parameters_from_agamemnon(agamemnon_params) if agamemnon_params else []
-    )
-
-
-def compare_params(load_centre_collect_params: LoadCentreCollect):
-    try:
-        lcc_requests = create_parameters_from_agamemnon()
-        # Log differences against GDA populated parameters
-        if not lcc_requests:
-            LOGGER.info("Agamemnon returned no instructions")
-        else:
-            differences = DeepDiff(
-                lcc_requests[0], load_centre_collect_params, math_epsilon=1e-5
-            )
-            if differences:
-                LOGGER.info(
-                    f"Different parameters found when directly reading from Hyperion: {differences}"
-                )
-    except (ValueError, KeyError):
-        LOGGER.warning(f"Failed to compare parameters: {traceback.format_exc()}")
-    except Exception:
-        LOGGER.warning(
-            f"Unexpected error occurred. Failed to compare parameters: {traceback.format_exc()}"
-        )
-
-
-def update_params_from_agamemnon(parameters: T) -> T:
-    try:
-        beamline_name = get_beamline_name("i03")
-        agamemnon_params = get_next_instruction(beamline_name)
-        pin_type = get_pin_type_from_agamemnon_parameters(agamemnon_params)
-        if isinstance(parameters, LoadCentreCollect):
-            parameters.robot_load_then_centre.tip_offset_um = pin_type.full_width / 2
-            parameters.robot_load_then_centre.grid_width_um = pin_type.full_width
-            parameters.select_centres.n = pin_type.expected_number_of_crystals
-            if pin_type != SinglePin():
-                # Rotation snapshots will be generated from the gridscan snapshots,
-                # no need to specify snapshot omega.
-                parameters.multi_rotation_scan.snapshot_omegas_deg = []
-                parameters.multi_rotation_scan.use_grid_snapshots = True
-    except (ValueError, ValidationError) as e:
-        LOGGER.warning(f"Failed to update parameters: {e}")
-    except Exception as e:
-        LOGGER.warning(f"Unexpected error occurred. Failed to update parameters: {e}")
-
-    return parameters

mx_bluesky/hyperion/external_interaction/alerting/constants.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class Subjects(StrEnum):
+    UDC_STARTED = "UDC Started"
+    UDC_BATON_PASSED = "UDC Baton was passed"
+    UDC_RESUMED_OPERATION = "UDC Resumed operation"
+    UDC_SUSPENDED_OPERATION = "UDC Suspended operation"
+    NEW_CONTAINER = "Hyperion is collecting from a new container"
+    NEW_VISIT = "Hyperion has changed visit"
+    SAMPLE_ERROR = "Hyperion has encountered a sample error"
+    BEAMLINE_ERROR = "Hyperion has encountered a beamline error"

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -8,6 +8,10 @@ from bluesky.callbacks.zmq import Proxy, RemoteDispatcher
 from dodal.log import LOGGER as dodal_logger
 from dodal.log import set_up_all_logging_handlers
 
+from mx_bluesky.common.external_interaction.alerting import set_alerting_service
+from mx_bluesky.common.external_interaction.alerting.log_based_service import (
+    LoggingAlertService,
+)
 from mx_bluesky.common.external_interaction.callbacks.common.log_uid_tag_callback import (
     LogUidTaggingCallback,
 )
@@ -29,6 +33,9 @@ from mx_bluesky.common.utils.log import (
     _get_logging_dirs,
     tag_filter,
 )
+from mx_bluesky.hyperion.external_interaction.callbacks.alert_on_container_change import (
+    AlertOnContainerChange,
+)
 from mx_bluesky.hyperion.external_interaction.callbacks.robot_actions.ispyb_callback import (
     RobotLoadISPyBCallback,
 )
@@ -85,6 +92,7 @@ def setup_callbacks() -> list[CallbackBase]:
         LogUidTaggingCallback(),
         RobotLoadISPyBCallback(),
         SampleHandlingCallback(),
+        AlertOnContainerChange(),
     ]
 
 
@@ -156,6 +164,7 @@ class HyperionCallbackRunner:
     def __init__(self, dev_mode) -> None:
         setup_logging(dev_mode)
         log_info("Hyperion callback process started.")
+        set_alerting_service(LoggingAlertService(CONST.GRAYLOG_STREAM_ID))
 
         self.callbacks = setup_callbacks()
         self.proxy, self.dispatcher, start_proxy, start_dispatcher = setup_threads()

mx_bluesky/hyperion/external_interaction/callbacks/alert_on_container_change.py

@@ -0,0 +1,54 @@
+from dodal.utils import get_beamline_name
+from event_model import Event, EventDescriptor, RunStart
+
+from mx_bluesky.common.external_interaction.alerting import (
+    Metadata,
+    get_alerting_service,
+)
+from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
+    PlanReactiveCallback,
+)
+from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER
+from mx_bluesky.hyperion.parameters.constants import CONST
+
+
+class AlertOnContainerChange(PlanReactiveCallback):
+    """Sends an alert to beamline staff when a pin from a new puck has been loaded.
+    This tends to be used as a heartbeat so we know that UDC is running."""
+
+    def __init__(self):
+        super().__init__(log=ISPYB_ZOCALO_CALLBACK_LOGGER)
+        self._new_container = None
+        self._visit = None
+        self._sample_id = None
+        self.descriptors: dict[str, EventDescriptor] = {}
+
+    def activity_gated_descriptor(self, doc: EventDescriptor) -> EventDescriptor | None:
+        self.descriptors[doc["uid"]] = doc
+        return super().activity_gated_descriptor(doc)
+
+    def activity_gated_event(self, doc: Event) -> Event | None:
+        event_descriptor = self.descriptors.get(doc["descriptor"])
+        if (
+            event_descriptor
+            and event_descriptor.get("name") == CONST.DESCRIPTORS.ROBOT_PRE_LOAD
+        ):
+            current_container = int(doc["data"]["robot-current_puck"])
+            if self._new_container != current_container:
+                beamline = get_beamline_name("")
+                get_alerting_service().raise_alert(
+                    f"UDC moved on to puck {self._new_container} on {beamline}",
+                    f"Hyperion finished container {current_container} and moved on to {self._new_container}",
+                    {
+                        Metadata.SAMPLE_ID: str(self._sample_id),
+                        Metadata.VISIT: self._visit or "",
+                        Metadata.CONTAINER: str(self._new_container),
+                    },
+                )
+        return doc
+
+    def activity_gated_start(self, doc: RunStart):
+        metadata = doc.get("metadata", {})
+        self._new_container = metadata.get("container")
+        self._sample_id = metadata.get("sample_id")
+        self._visit = metadata.get("visit")

mx_bluesky/hyperion/external_interaction/callbacks/rotation/nexus_callback.py

@@ -15,7 +15,7 @@ from mx_bluesky.common.external_interaction.nexus.nexus_utils import (
 )
 from mx_bluesky.common.external_interaction.nexus.write_nexus import NexusWriter
 from mx_bluesky.common.utils.log import NEXUS_LOGGER
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 
 if TYPE_CHECKING:
@@ -103,6 +103,6 @@ class RotationNexusFileCallback(PlanReactiveCallback):
                 full_num_of_images=self.full_num_of_images,
                 meta_data_run_number=self.meta_data_run_number,
                 axis_direction=AxisDirection.NEGATIVE
-                if parameters.features.omega_flip
+                if I03Constants.OMEGA_FLIP
                 else AxisDirection.POSITIVE,
             )

mx_bluesky/hyperion/external_interaction/config_server.py

@@ -1,35 +1,16 @@
 from functools import cache
 
-from daq_config_server.client import ConfigServer
+from mx_bluesky.common.external_interaction.config_server import MXConfigClient
+from mx_bluesky.hyperion.parameters.constants import (
+    HyperionFeatureSetting,
+    HyperionFeatureSettingources,
+)
 
-from mx_bluesky.common.external_interaction.config_server import FeatureFlags
-from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.parameters.constants import CONST
 
-
-class HyperionFeatureFlags(FeatureFlags):
-    """
-    Feature flags specific to Hyperion.
-
-    Attributes:
-        use_panda_for_gridscan:         If True then the PandA is used for gridscans, otherwise the zebra is used
-        use_gpu_results:                If True then GPU result processing is enabled
-            and the GPU result is taken.
-        set_stub_offsets:               If True then set the stub offsets after moving to the crystal (ignored for
-            multi-centre)
-        omega_flip:                     If True then invert the smargon omega motor rotation commands with respect to
-         the hyperion request. See "Hyperion Coordinate Systems" in the documentation.
-        alternate_rotation_direction:   If True then the for multi-sample pins the rotation direction of
-         successive rotation scans is alternated between positive and negative.
-    """
-
-    @staticmethod
-    @cache
-    def get_config_server() -> ConfigServer:
-        return ConfigServer(CONST.CONFIG_SERVER_URL, LOGGER)
-
-    use_panda_for_gridscan: bool = CONST.I03.USE_PANDA_FOR_GRIDSCAN
-    use_gpu_results: bool = CONST.I03.USE_GPU_RESULTS
-    set_stub_offsets: bool = CONST.I03.SET_STUB_OFFSETS
-    omega_flip: bool = CONST.I03.OMEGA_FLIP
-    alternate_rotation_direction: bool = CONST.I03.ALTERNATE_ROTATION_DIRECTION
+@cache
+def get_hyperion_config_client() -> MXConfigClient[HyperionFeatureSetting]:
+    return MXConfigClient(
+        feature_sources=HyperionFeatureSettingources,
+        feature_dc=HyperionFeatureSetting,
+        url="https://daq-config.diamond.ac.uk",
+    )

mx_bluesky/hyperion/parameters/cli.py

@@ -1,12 +1,19 @@
 import argparse
+from enum import StrEnum
 
 from pydantic.dataclasses import dataclass
 
 from mx_bluesky._version import version
 
 
+class HyperionMode(StrEnum):
+    GDA = "gda"
+    UDC = "udc"
+
+
 @dataclass
 class HyperionArgs:
+    mode: HyperionMode
     dev_mode: bool = False
 
 
@@ -39,7 +46,12 @@ def parse_cli_args() -> HyperionArgs:
         action="version",
         version=version,
     )
-    args = parser.parse_args()
-    return HyperionArgs(
-        dev_mode=args.dev or False,
+    parser.add_argument(
+        "--mode",
+        help="Launch in the specified mode (default is 'gda')",
+        default=HyperionMode.GDA,
+        type=HyperionMode,
+        choices=HyperionMode.__members__.values(),
     )
+    args = parser.parse_args()
+    return HyperionArgs(dev_mode=args.dev or False, mode=args.mode)

mx_bluesky/hyperion/parameters/components.py

@@ -1,8 +1,10 @@
-from pydantic import Field
+from mx_bluesky.common.parameters.components import MxBlueskyParameters
 
-from mx_bluesky.common.parameters.components import WithPandaGridScan
-from mx_bluesky.hyperion.external_interaction.config_server import HyperionFeatureFlags
 
+class Wait(MxBlueskyParameters):
+    """Represents an instruction from Agamemnon for Hyperion to wait for a specified time
+    Attributes:
+        duration_s: duration to wait in seconds
+    """
 
-class WithHyperionUDCFeatures(WithPandaGridScan):
-    features: HyperionFeatureFlags = Field(default=HyperionFeatureFlags())
+    duration_s: float