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

mx_bluesky/hyperion/external_interaction/callbacks/grid_detection_callback.py

@@ -2,7 +2,6 @@ from typing import TypedDict
 
 import numpy as np
 from bluesky.callbacks import CallbackBase
-from dodal.devices.oav.oav_detector import OAVConfigParams
 from dodal.devices.oav.utils import calculate_x_y_z_of_pixel
 from event_model.documents import Event
 
@@ -26,21 +25,19 @@ class GridParamUpdate(TypedDict):
 class GridDetectionCallback(CallbackBase):
     def __init__(
         self,
-        oav_params: OAVConfigParams,
         *args,
     ) -> None:
         super().__init__(*args)
-        self.oav_params = oav_params
-        self.start_positions: list = []
+        self.start_positions_mm: list = []
         self.box_numbers: list = []
 
     def event(self, doc: Event):
         data = doc.get("data")
-        top_left_x_px = data["oav_grid_snapshot_top_left_x"]
-        box_width_px = data["oav_grid_snapshot_box_width"]
+        top_left_x_px = data["oav-grid_snapshot-top_left_x"]
+        box_width_px = data["oav-grid_snapshot-box_width"]
         x_of_centre_of_first_box_px = top_left_x_px + box_width_px / 2
 
-        top_left_y_px = data["oav_grid_snapshot_top_left_y"]
+        top_left_y_px = data["oav-grid_snapshot-top_left_y"]
         y_of_centre_of_first_box_px = top_left_y_px + box_width_px / 2
 
         smargon_omega = data["smargon-omega"]
@@ -53,36 +50,44 @@ class GridDetectionCallback(CallbackBase):
             y_of_centre_of_first_box_px,
         )
 
-        position_grid_start = calculate_x_y_z_of_pixel(
-            current_xyz, smargon_omega, centre_of_first_box, self.oav_params
-        )
+        microns_per_pixel_x = data["oav-microns_per_pixel_x"]
+        microns_per_pixel_y = data["oav-microns_per_pixel_y"]
+        beam_x = data["oav-beam_centre_i"]
+        beam_y = data["oav-beam_centre_j"]
 
-        LOGGER.info(f"Calculated start position {position_grid_start}")
+        position_grid_start_mm = calculate_x_y_z_of_pixel(
+            current_xyz,
+            smargon_omega,
+            centre_of_first_box,
+            (beam_x, beam_y),
+            (microns_per_pixel_x, microns_per_pixel_y),
+        )
+        LOGGER.info(f"Calculated start position {position_grid_start_mm}")
 
-        self.start_positions.append(position_grid_start)
+        self.start_positions_mm.append(position_grid_start_mm)
         self.box_numbers.append(
             (
-                data["oav_grid_snapshot_num_boxes_x"],
-                data["oav_grid_snapshot_num_boxes_y"],
+                data["oav-grid_snapshot-num_boxes_x"],
+                data["oav-grid_snapshot-num_boxes_y"],
             )
         )
 
-        self.x_step_size_mm = box_width_px * self.oav_params.micronsPerXPixel / 1000
-        self.y_step_size_mm = box_width_px * self.oav_params.micronsPerYPixel / 1000
-        self.z_step_size_mm = box_width_px * self.oav_params.micronsPerYPixel / 1000
+        self.x_step_size_um = box_width_px * microns_per_pixel_x
+        self.y_step_size_um = box_width_px * microns_per_pixel_y
+        self.z_step_size_um = box_width_px * microns_per_pixel_y
         return doc
 
     def get_grid_parameters(self) -> GridParamUpdate:
         return {
-            "x_start_um": self.start_positions[0][0],
-            "y_start_um": self.start_positions[0][1],
-            "y2_start_um": self.start_positions[0][1],
-            "z_start_um": self.start_positions[1][2],
-            "z2_start_um": self.start_positions[1][2],
+            "x_start_um": self.start_positions_mm[0][0] * 1000,
+            "y_start_um": self.start_positions_mm[0][1] * 1000,
+            "y2_start_um": self.start_positions_mm[0][1] * 1000,
+            "z_start_um": self.start_positions_mm[1][2] * 1000,
+            "z2_start_um": self.start_positions_mm[1][2] * 1000,
             "x_steps": self.box_numbers[0][0],
             "y_steps": self.box_numbers[0][1],
             "z_steps": self.box_numbers[1][1],
-            "x_step_size_um": self.x_step_size_mm,
-            "y_step_size_um": self.y_step_size_mm,
-            "z_step_size_um": self.z_step_size_mm,
+            "x_step_size_um": self.x_step_size_um,
+            "y_step_size_um": self.y_step_size_um,
+            "z_step_size_um": self.z_step_size_um,
         }

mx_bluesky/hyperion/external_interaction/callbacks/ispyb_callback_base.py

@@ -5,9 +5,12 @@ from collections.abc import Callable, Sequence
 from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 from dodal.beamline_specific_utils.i03 import beam_size_from_aperture
+from dodal.devices.detector import DetectorParams
 from dodal.devices.detector.det_resolution import resolution
 from dodal.devices.synchrotron import SynchrotronMode
 
+from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
+from mx_bluesky.common.utils.log import set_dcgid_tag
 from mx_bluesky.hyperion.external_interaction.callbacks.plan_reactive_callback import (
     PlanReactiveCallback,
 )
@@ -21,8 +24,7 @@ from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
     StoreInIspyb,
 )
 from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_utils import get_ispyb_config
-from mx_bluesky.hyperion.log import ISPYB_LOGGER, set_dcgid_tag
-from mx_bluesky.hyperion.parameters.components import DiffractionExperimentWithSample
+from mx_bluesky.hyperion.log import ISPYB_LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.utils.utils import convert_eV_to_angstrom
 
@@ -33,6 +35,25 @@ if TYPE_CHECKING:
     from event_model.documents import Event, EventDescriptor, RunStart, RunStop
 
 
+def _update_based_on_energy(
+    doc: Event,
+    detector_params: DetectorParams,
+    data_collection_info: DataCollectionInfo,
+):
+    """If energy has been read as part of this reading then add it into the data
+    collection info along with the other fields that depend on it."""
+    if energy_kev := doc["data"].get("dcm-energy_in_kev", None):
+        energy_ev = energy_kev * 1000
+        wavelength_angstroms = convert_eV_to_angstrom(energy_ev)
+        data_collection_info.wavelength = wavelength_angstroms
+        data_collection_info.resolution = resolution(
+            detector_params,
+            wavelength_angstroms,
+            detector_params.detector_distance,
+        )
+    return data_collection_info
+
+
 class BaseISPyBCallback(PlanReactiveCallback):
     def __init__(
         self,
@@ -109,6 +130,9 @@ class BaseISPyBCallback(PlanReactiveCallback):
             slitgap_horizontal=doc["data"]["s4_slit_gaps_xgap"],
             slitgap_vertical=doc["data"]["s4_slit_gaps_ygap"],
         )
+        hwscan_data_collection_info = _update_based_on_energy(
+            doc, self.params.detector_params, hwscan_data_collection_info
+        )
         hwscan_position_info = DataCollectionPositionInfo(
             pos_x=float(doc["data"]["smargon-x"]),
             pos_y=float(doc["data"]["smargon-y"]),
@@ -137,16 +161,9 @@ class BaseISPyBCallback(PlanReactiveCallback):
         if transmission := doc["data"]["attenuator-actual_transmission"]:
             # Ispyb wants the transmission in a percentage, we use fractions
             hwscan_data_collection_info.transmission = transmission * 100
-        event_energy = doc["data"]["dcm-energy_in_kev"]
-        if event_energy:
-            energy_ev = event_energy * 1000
-            wavelength_angstroms = convert_eV_to_angstrom(energy_ev)
-            hwscan_data_collection_info.wavelength = wavelength_angstroms
-            hwscan_data_collection_info.resolution = resolution(
-                self.params.detector_params,
-                wavelength_angstroms,
-                self.params.detector_params.detector_distance,
-            )
+        hwscan_data_collection_info = _update_based_on_energy(
+            doc, self.params.detector_params, hwscan_data_collection_info
+        )
         scan_data_infos = self.populate_info_for_update(
             hwscan_data_collection_info, None, self.params
         )

mx_bluesky/hyperion/external_interaction/callbacks/log_uid_tag_callback.py

@@ -1,7 +1,7 @@
 from bluesky.callbacks import CallbackBase
 from event_model import RunStart, RunStop
 
-from mx_bluesky.hyperion.log import set_uid_tag
+from mx_bluesky.common.utils.log import set_uid_tag
 
 
 class LogUidTaggingCallback(CallbackBase):

mx_bluesky/hyperion/external_interaction/callbacks/robot_load/ispyb_callback.py

@@ -2,8 +2,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from event_model.documents import EventDescriptor
-
 from mx_bluesky.hyperion.external_interaction.callbacks.common.ispyb_mapping import (
     get_proposal_and_session_from_visit_string,
 )
@@ -11,6 +9,7 @@ from mx_bluesky.hyperion.external_interaction.callbacks.plan_reactive_callback i
     PlanReactiveCallback,
 )
 from mx_bluesky.hyperion.external_interaction.ispyb.exp_eye_store import (
+    BLSampleStatus,
     ExpeyeInteraction,
     RobotActionID,
 )
@@ -25,6 +24,7 @@ class RobotLoadISPyBCallback(PlanReactiveCallback):
     def __init__(self) -> None:
         ISPYB_LOGGER.debug("Initialising ISPyB Robot Load Callback")
         super().__init__(log=ISPYB_LOGGER)
+        self._metadata: dict | None = None
         self.run_uid: str | None = None
         self.descriptors: dict[str, EventDescriptor] = {}
         self.action_id: RobotActionID | None = None
@@ -35,16 +35,17 @@ class RobotLoadISPyBCallback(PlanReactiveCallback):
         if doc.get("subplan_name") == CONST.PLAN.ROBOT_LOAD:
             ISPYB_LOGGER.debug(f"ISPyB robot load callback received: {doc}")
             self.run_uid = doc.get("uid")
-            assert isinstance(metadata := doc.get("metadata"), dict)
+            self._metadata = doc.get("metadata")
+            assert isinstance(self._metadata, dict)
             proposal, session = get_proposal_and_session_from_visit_string(
-                metadata["visit"]
+                self._metadata["visit"]
             )
             self.action_id = self.expeye.start_load(
                 proposal,
                 session,
-                metadata["sample_id"],
-                metadata["sample_puck"],
-                metadata["sample_pin"],
+                self._metadata["sample_id"],
+                self._metadata["sample_puck"],
+                self._metadata["sample_pin"],
             )
         return super().activity_gated_start(doc)
 
@@ -62,7 +63,7 @@ class RobotLoadISPyBCallback(PlanReactiveCallback):
                 self.action_id is not None
             ), "ISPyB Robot load callback event called unexpectedly"
             barcode = doc["data"]["robot-barcode"]
-            oav_snapshot = doc["data"]["oav_snapshot_last_saved_path"]
+            oav_snapshot = doc["data"]["oav-snapshot-last_saved_path"]
             webcam_snapshot = doc["data"]["webcam-last_saved_path"]
             # I03 uses webcam/oav snapshots in place of before/after snapshots
             self.expeye.update_barcode_and_snapshots(
@@ -77,10 +78,17 @@ class RobotLoadISPyBCallback(PlanReactiveCallback):
             assert (
                 self.action_id is not None
             ), "ISPyB Robot load callback stop called unexpectedly"
-            exit_status = (
-                doc.get("exit_status") or "Exit status not available in stop document!"
-            )
+            exit_status = doc.get("exit_status")
+            assert exit_status, "Exit status not available in stop document!"
+            assert self._metadata, "Metadata not received before stop document."
             reason = doc.get("reason") or "OK"
+
             self.expeye.end_load(self.action_id, exit_status, reason)
+            self.expeye.update_sample_status(
+                self._metadata["sample_id"],
+                BLSampleStatus.LOADED
+                if exit_status == "success"
+                else BLSampleStatus.ERROR_BEAMLINE,
+            )
             self.action_id = None
         return super().activity_gated_stop(doc)

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

@@ -3,6 +3,8 @@ from __future__ import annotations
 from collections.abc import Callable, Sequence
 from typing import TYPE_CHECKING, Any, cast
 
+from mx_bluesky.common.parameters.components import IspybExperimentType
+from mx_bluesky.common.utils.log import set_dcgid_tag
 from mx_bluesky.hyperion.external_interaction.callbacks.common.ispyb_mapping import (
     populate_data_collection_group,
     populate_remaining_data_collection_info,
@@ -22,8 +24,7 @@ from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
     IspybIds,
     StoreInIspyb,
 )
-from mx_bluesky.hyperion.log import ISPYB_LOGGER, set_dcgid_tag
-from mx_bluesky.hyperion.parameters.components import IspybExperimentType
+from mx_bluesky.hyperion.log import ISPYB_LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.rotation import RotationScan
 
@@ -60,7 +61,9 @@ class RotationISPyBCallback(BaseISPyBCallback):
             ISPYB_LOGGER.info(
                 "ISPyB callback received start document with experiment parameters."
             )
-            self.params = RotationScan.from_json(doc.get("hyperion_parameters"))
+            hyperion_params = doc.get("hyperion_parameters")
+            assert isinstance(hyperion_params, str)
+            self.params = RotationScan.model_validate_json(hyperion_params)
             dcgid = (
                 self.ispyb_ids.data_collection_group_id
                 if (self.params.sample_id == self.last_sample_id)
@@ -157,7 +160,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
         data_collection_info = DataCollectionInfo(
             **{
                 f"xtal_snapshot{self._oav_snapshot_event_idx}": data.get(
-                    "oav_snapshot_last_saved_path"
+                    "oav-snapshot-last_saved_path"
                 )
             }
         )

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

@@ -78,12 +78,14 @@ class RotationNexusFileCallback(PlanReactiveCallback):
             self.meta_data_run_number = doc.get("meta_data_run_number")
         if doc.get("subplan_name") == CONST.PLAN.ROTATION_OUTER:
             self.run_uid = doc.get("uid")
-            json_params = doc.get("hyperion_parameters")
+            hyperion_params = doc.get("hyperion_parameters")
+            assert isinstance(hyperion_params, str)
             NEXUS_LOGGER.info(
-                f"Nexus writer received start document with experiment parameters {json_params}"
+                f"Nexus writer received start document with experiment parameters {hyperion_params}"
             )
-            parameters = RotationScan.from_json(json_params)
+            parameters = RotationScan.model_validate_json(hyperion_params)
             NEXUS_LOGGER.info("Setting up nexus file...")
+
             det_size = (
                 parameters.detector_params.detector_size_constants.det_size_pixels
             )

mx_bluesky/hyperion/external_interaction/callbacks/sample_handling/sample_handling_callback.py

@@ -0,0 +1,84 @@
+import dataclasses
+from collections.abc import Generator
+from functools import partial
+from typing import Any
+
+import bluesky.plan_stubs as bps
+from bluesky.preprocessors import contingency_wrapper
+from bluesky.utils import Msg, make_decorator
+from event_model import Event, EventDescriptor, RunStart
+
+from mx_bluesky.hyperion.exceptions import CrystalNotFoundException, SampleException
+from mx_bluesky.hyperion.external_interaction.callbacks.common.abstract_event import (
+    AbstractEvent,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.plan_reactive_callback import (
+    PlanReactiveCallback,
+)
+from mx_bluesky.hyperion.external_interaction.ispyb.exp_eye_store import (
+    BLSampleStatus,
+    ExpeyeInteraction,
+)
+from mx_bluesky.hyperion.log import ISPYB_LOGGER
+from mx_bluesky.hyperion.parameters.constants import CONST
+
+# TODO remove this event-raising shenanigans once
+# https://github.com/bluesky/bluesky/issues/1829 is addressed
+
+
+@dataclasses.dataclass(frozen=True)
+class _ExceptionEvent(AbstractEvent):
+    exception_type: str
+
+
+def _exception_interceptor(exception: Exception) -> Generator[Msg, Any, Any]:
+    yield from bps.create(CONST.DESCRIPTORS.SAMPLE_HANDLING_EXCEPTION)
+    yield from bps.read(_ExceptionEvent(type(exception).__name__))
+    yield from bps.save()
+
+
+sample_handling_callback_decorator = make_decorator(
+    partial(contingency_wrapper, except_plan=_exception_interceptor)
+)
+
+
+class SampleHandlingCallback(PlanReactiveCallback):
+    """Intercepts exceptions from experiment plans and updates the ISPyB BLSampleStatus
+    field according to the type of exception raised."""
+
+    def __init__(self):
+        super().__init__(log=ISPYB_LOGGER)
+        self._sample_id: int | None = None
+        self._descriptor: str | None = None
+
+    def activity_gated_start(self, doc: RunStart):
+        if not self._sample_id:
+            sample_id = doc.get("metadata", {}).get("sample_id")
+            self.log.info(f"Recording sample ID at run start {sample_id}")
+            self._sample_id = sample_id
+
+    def activity_gated_descriptor(self, doc: EventDescriptor) -> EventDescriptor | None:
+        if doc.get("name") == CONST.DESCRIPTORS.SAMPLE_HANDLING_EXCEPTION:
+            self._descriptor = doc["uid"]
+        return super().activity_gated_descriptor(doc)
+
+    def activity_gated_event(self, doc: Event) -> Event | None:
+        if doc["descriptor"] == self._descriptor:
+            exception_type = doc["data"]["exception_type"]
+            self.log.info(
+                f"Sample handling callback intercepted exception of type {exception_type}"
+            )
+            self._record_exception(exception_type)
+        return doc
+
+    def _record_exception(self, exception_type: str):
+        expeye = ExpeyeInteraction()
+        assert self._sample_id, "Unable to record exception due to no sample ID"
+        sample_status = self._decode_sample_status(exception_type)
+        expeye.update_sample_status(self._sample_id, sample_status)
+
+    def _decode_sample_status(self, exception_type: str) -> BLSampleStatus:
+        match exception_type:
+            case SampleException.__name__ | CrystalNotFoundException.__name__:
+                return BLSampleStatus.ERROR_SAMPLE
+        return BLSampleStatus.ERROR_BEAMLINE

mx_bluesky/hyperion/external_interaction/callbacks/xray_centre/ispyb_callback.py

@@ -5,10 +5,16 @@ from time import time
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
-from blueapi.core import MsgGenerator
 from bluesky import preprocessors as bpp
-from dodal.devices.zocalo.zocalo_results import ZOCALO_READING_PLAN_NAME
+from bluesky.utils import MsgGenerator
+from dodal.devices.zocalo.zocalo_results import (
+    ZOCALO_READING_PLAN_NAME,
+    get_processing_results_from_event,
+)
 
+from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
+from mx_bluesky.common.parameters.constants import PlanNameConstants
+from mx_bluesky.common.utils.log import set_dcgid_tag
 from mx_bluesky.hyperion.external_interaction.callbacks.common.ispyb_mapping import (
     populate_data_collection_group,
     populate_remaining_data_collection_info,
@@ -36,8 +42,7 @@ from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
     IspybIds,
     StoreInIspyb,
 )
-from mx_bluesky.hyperion.log import ISPYB_LOGGER, set_dcgid_tag
-from mx_bluesky.hyperion.parameters.components import DiffractionExperimentWithSample
+from mx_bluesky.hyperion.log import ISPYB_LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.gridscan import (
     GridCommon,
@@ -48,13 +53,16 @@ if TYPE_CHECKING:
 
 
 def ispyb_activation_wrapper(plan_generator: MsgGenerator, parameters):
-    return bpp.run_wrapper(
-        plan_generator,
-        md={
-            "activate_callbacks": ["GridscanISPyBCallback"],
-            "subplan_name": CONST.PLAN.GRID_DETECT_AND_DO_GRIDSCAN,
-            "hyperion_parameters": parameters.model_dump_json(),
-        },
+    return bpp.set_run_key_wrapper(
+        bpp.run_wrapper(
+            plan_generator,
+            md={
+                "activate_callbacks": ["GridscanISPyBCallback"],
+                "subplan_name": CONST.PLAN.GRID_DETECT_AND_DO_GRIDSCAN,
+                "hyperion_parameters": parameters.model_dump_json(),
+            },
+        ),
+        CONST.PLAN.ISPYB_ACTIVATION,
     )
 
 
@@ -85,7 +93,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         self._processing_start_time: float | None = None
 
     def activity_gated_start(self, doc: RunStart):
-        if doc.get("subplan_name") == CONST.PLAN.DO_FGS:
+        if doc.get("subplan_name") == PlanNameConstants.DO_FGS:
             self._start_of_fgs_uid = doc.get("uid")
         if doc.get("subplan_name") == CONST.PLAN.GRID_DETECT_AND_DO_GRIDSCAN:
             self.uid_to_finalize_on = doc.get("uid")
@@ -93,7 +101,9 @@ class GridscanISPyBCallback(BaseISPyBCallback):
                 "ISPyB callback received start document with experiment parameters and "
                 f"uid: {self.uid_to_finalize_on}"
             )
-            self.params = GridCommon.from_json(doc.get("hyperion_parameters"))
+            hyperion_params = doc.get("hyperion_parameters")
+            assert isinstance(hyperion_params, str)
+            self.params = GridCommon.model_validate_json(hyperion_params)
             self.ispyb = StoreInIspyb(self.ispyb_config)
             data_collection_group_info = populate_data_collection_group(self.params)
 
@@ -147,7 +157,8 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         ISPYB_LOGGER.info(
             f"Amending comment based on Zocalo reading doc: {format_doc_for_log(doc)}"
         )
-        raw_results = doc["data"]["zocalo-results"]
+
+        raw_results = get_processing_results_from_event("zocalo", doc)
         if len(raw_results) > 0:
             for n, res in enumerate(raw_results):
                 bb = res["bounding_box"]
@@ -178,25 +189,25 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         data = doc["data"]
         data_collection_id = None
         data_collection_info = DataCollectionInfo(
-            xtal_snapshot1=data.get("oav_grid_snapshot_last_path_full_overlay"),
-            xtal_snapshot2=data.get("oav_grid_snapshot_last_path_outer"),
-            xtal_snapshot3=data.get("oav_grid_snapshot_last_saved_path"),
+            xtal_snapshot1=data.get("oav-grid_snapshot-last_path_full_overlay"),
+            xtal_snapshot2=data.get("oav-grid_snapshot-last_path_outer"),
+            xtal_snapshot3=data.get("oav-grid_snapshot-last_saved_path"),
             n_images=(
-                data["oav_grid_snapshot_num_boxes_x"]
-                * data["oav_grid_snapshot_num_boxes_y"]
+                data["oav-grid_snapshot-num_boxes_x"]
+                * data["oav-grid_snapshot-num_boxes_y"]
             ),
         )
-        microns_per_pixel_x = data["oav_grid_snapshot_microns_per_pixel_x"]
-        microns_per_pixel_y = data["oav_grid_snapshot_microns_per_pixel_y"]
+        microns_per_pixel_x = data["oav-microns_per_pixel_x"]
+        microns_per_pixel_y = data["oav-microns_per_pixel_y"]
         data_collection_grid_info = DataCollectionGridInfo(
-            dx_in_mm=data["oav_grid_snapshot_box_width"] * microns_per_pixel_x / 1000,
-            dy_in_mm=data["oav_grid_snapshot_box_width"] * microns_per_pixel_y / 1000,
-            steps_x=data["oav_grid_snapshot_num_boxes_x"],
-            steps_y=data["oav_grid_snapshot_num_boxes_y"],
+            dx_in_mm=data["oav-grid_snapshot-box_width"] * microns_per_pixel_x / 1000,
+            dy_in_mm=data["oav-grid_snapshot-box_width"] * microns_per_pixel_y / 1000,
+            steps_x=data["oav-grid_snapshot-num_boxes_x"],
+            steps_y=data["oav-grid_snapshot-num_boxes_y"],
             microns_per_pixel_x=microns_per_pixel_x,
             microns_per_pixel_y=microns_per_pixel_y,
-            snapshot_offset_x_pixel=int(data["oav_grid_snapshot_top_left_x"]),
-            snapshot_offset_y_pixel=int(data["oav_grid_snapshot_top_left_y"]),
+            snapshot_offset_x_pixel=int(data["oav-grid_snapshot-top_left_x"]),
+            snapshot_offset_y_pixel=int(data["oav-grid_snapshot-top_left_y"]),
             orientation=Orientation.HORIZONTAL,
             snaked=True,
         )

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

@@ -12,7 +12,7 @@ from mx_bluesky.hyperion.external_interaction.nexus.nexus_utils import (
 from mx_bluesky.hyperion.external_interaction.nexus.write_nexus import NexusWriter
 from mx_bluesky.hyperion.log import NEXUS_LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.gridscan import ThreeDGridScan
+from mx_bluesky.hyperion.parameters.gridscan import HyperionThreeDGridScan
 
 if TYPE_CHECKING:
     from event_model.documents import Event, EventDescriptor, RunStart
@@ -45,11 +45,12 @@ class GridscanNexusFileCallback(PlanReactiveCallback):
 
     def activity_gated_start(self, doc: RunStart):
         if doc.get("subplan_name") == CONST.PLAN.GRIDSCAN_OUTER:
-            json_params = doc.get("hyperion_parameters")
+            hyperion_params = doc.get("hyperion_parameters")
+            assert isinstance(hyperion_params, str)
             NEXUS_LOGGER.info(
-                f"Nexus writer received start document with experiment parameters {json_params}"
+                f"Nexus writer received start document with experiment parameters {hyperion_params}"
             )
-            parameters = ThreeDGridScan.from_json(json_params)
+            parameters = HyperionThreeDGridScan.model_validate_json(hyperion_params)
             d_size = parameters.detector_params.detector_size_constants.det_size_pixels
             grid_n_img_1 = parameters.scan_indices[1]
             grid_n_img_2 = parameters.num_images - grid_n_img_1

mx_bluesky/hyperion/external_interaction/config_server.py

@@ -1,35 +1,18 @@
+from functools import cache
+
 from daq_config_server.client import ConfigServer
-from pydantic import BaseModel
 
+from mx_bluesky.common.external_interaction.config_server import FeatureFlags
 from mx_bluesky.hyperion.log import LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 
-_CONFIG_SERVER: ConfigServer | None = None
-
-
-def config_server() -> ConfigServer:
-    global _CONFIG_SERVER
-    if _CONFIG_SERVER is None:
-        _CONFIG_SERVER = ConfigServer(CONST.CONFIG_SERVER_URL, LOGGER)
-    return _CONFIG_SERVER
-
-
-class FeatureFlags(BaseModel):
-    # The default value will be used as the fallback when doing a best-effort fetch
-    # from the service
-    use_panda_for_gridscan: bool = False
-    use_gpu_for_gridscan: bool = False
-    set_stub_offsets: bool = False
-
-    @classmethod
-    def _get_flags(cls):
-        flags = config_server().best_effort_get_all_feature_flags()
-        return {f: flags[f] for f in flags if f in cls.__fields__.keys()}
 
-    @classmethod
-    def best_effort(cls):
-        return cls(**cls._get_flags())
+class HyperionFeatureFlags(FeatureFlags):
+    @staticmethod
+    @cache
+    def get_config_server() -> ConfigServer:
+        return ConfigServer(CONST.CONFIG_SERVER_URL, LOGGER)
 
-    def update_self_from_server(self):
-        for flag, value in self._get_flags().items():
-            setattr(self, flag, value)
+    use_panda_for_gridscan: bool = CONST.I03.USE_PANDA_FOR_GRIDSCAN
+    compare_cpu_and_gpu_zocalo: bool = CONST.I03.COMPARE_CPU_AND_GPU_ZOCALO
+    set_stub_offsets: bool = CONST.I03.SET_STUB_OFFSETS

mx_bluesky/hyperion/external_interaction/exceptions.py

@@ -1,13 +1,4 @@
-from mx_bluesky.hyperion.exceptions import WarningException
-
-
 class ISPyBDepositionNotMade(Exception):
     """Raised when the ISPyB or Zocalo callbacks can't access ISPyB deposition numbers."""
 
     pass
-
-
-class NoCentreFoundException(WarningException):
-    """Error for if zocalo is unable to find the centre during a gridscan."""
-
-    pass