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

mx_bluesky/hyperion/experiment_plans/robot_load_then_centre_plan.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
-import dataclasses
 from typing import cast
 
-from blueapi.core import BlueskyContext, MsgGenerator
+import bluesky.preprocessors as bpp
+import pydantic
+from blueapi.core import BlueskyContext
+from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.backlight import Backlight
@@ -32,26 +34,36 @@ from dodal.log import LOGGER
 from ophyd_async.fastcs.panda import HDFPanda
 
 from mx_bluesky.common.parameters.constants import OavConstants
+from mx_bluesky.common.parameters.gridscan import RobotLoadThenCentre
 from mx_bluesky.hyperion.device_setup_plans.utils import (
     fill_in_energy_if_not_supplied,
     start_preparing_data_collection_then_do_plan,
 )
+from mx_bluesky.hyperion.experiment_plans.change_aperture_then_move_plan import (
+    change_aperture_then_move_to_xtal,
+)
+from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
+    XRayCentreEventHandler,
+)
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     GridDetectThenXRayCentreComposite,
 )
 from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan import (
-    pin_centre_then_xray_centre_plan,
+    pin_centre_then_flyscan_plan,
 )
 from mx_bluesky.hyperion.experiment_plans.robot_load_and_change_energy import (
     RobotLoadAndEnergyChangeComposite,
     pin_already_loaded,
     robot_load_and_change_energy_plan,
 )
+from mx_bluesky.hyperion.experiment_plans.set_energy_plan import (
+    SetEnergyComposite,
+    set_energy_plan,
+)
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.gridscan import RobotLoadThenCentre
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class RobotLoadThenCentreComposite:
     # common fields
     xbpm_feedback: XBPMFeedback
@@ -88,6 +100,10 @@ class RobotLoadThenCentreComposite:
     webcam: Webcam
     lower_gonio: XYZPositioner
 
+    @property
+    def sample_motors(self):
+        return self.smargon
+
 
 def create_devices(context: BlueskyContext) -> RobotLoadThenCentreComposite:
     from mx_bluesky.hyperion.utils.context import device_composite_from_context
@@ -95,18 +111,18 @@ def create_devices(context: BlueskyContext) -> RobotLoadThenCentreComposite:
     return device_composite_from_context(context, RobotLoadThenCentreComposite)
 
 
-def centring_plan_from_robot_load_params(
+def _flyscan_plan_from_robot_load_params(
     composite: RobotLoadThenCentreComposite,
     params: RobotLoadThenCentre,
     oav_config_file: str = OavConstants.OAV_CONFIG_JSON,
 ):
-    yield from pin_centre_then_xray_centre_plan(
+    yield from pin_centre_then_flyscan_plan(
         cast(GridDetectThenXRayCentreComposite, composite),
         params.pin_centre_then_xray_centre_params(),
     )
 
 
-def robot_load_then_centre_plan(
+def _robot_load_then_flyscan_plan(
     composite: RobotLoadThenCentreComposite,
     params: RobotLoadThenCentre,
     oav_config_file: str = OavConstants.OAV_CONFIG_JSON,
@@ -116,13 +132,36 @@ def robot_load_then_centre_plan(
         params.robot_load_params(),
     )
 
-    yield from centring_plan_from_robot_load_params(composite, params, oav_config_file)
+    yield from _flyscan_plan_from_robot_load_params(composite, params, oav_config_file)
 
 
 def robot_load_then_centre(
     composite: RobotLoadThenCentreComposite,
     parameters: RobotLoadThenCentre,
 ) -> MsgGenerator:
+    """Perform pin-tip detection followed by a flyscan to determine centres of interest.
+    Performs a robot load if necessary. Centre on the best diffracting centre.
+    """
+
+    xray_centre_event_handler = XRayCentreEventHandler()
+
+    yield from bpp.subs_wrapper(
+        robot_load_then_xray_centre(composite, parameters), xray_centre_event_handler
+    )
+    flyscan_results = xray_centre_event_handler.xray_centre_results
+    if flyscan_results is not None:
+        yield from change_aperture_then_move_to_xtal(
+            flyscan_results[0], composite.smargon, composite.aperture_scatterguard
+        )
+    # else no chi change, no need to recentre.
+
+
+def robot_load_then_xray_centre(
+    composite: RobotLoadThenCentreComposite,
+    parameters: RobotLoadThenCentre,
+) -> MsgGenerator:
+    """Perform pin-tip detection followed by a flyscan to determine centres of interest.
+    Performs a robot load if necessary."""
     eiger: EigerDetector = composite.eiger
 
     # TODO: get these from one source of truth #254
@@ -138,17 +177,26 @@ def robot_load_then_centre(
     doing_chi_change = parameters.chi_start_deg is not None
 
     if doing_sample_load:
-        plan = robot_load_then_centre_plan(
+        LOGGER.info("Pin not loaded, loading and centring")
+        plan = _robot_load_then_flyscan_plan(
             composite,
             parameters,
         )
-        LOGGER.info("Pin not loaded, loading and centring")
-    elif doing_chi_change:
-        plan = centring_plan_from_robot_load_params(composite, parameters)
-        LOGGER.info("Pin already loaded but chi changed so centring")
     else:
-        LOGGER.info("Pin already loaded and chi not changed so doing nothing")
-        return
+        # Robot load normally sets the energy so we should do this explicitly if no load is
+        # being done
+        demand_energy_ev = parameters.demand_energy_ev
+        LOGGER.info(f"Setting the energy to {demand_energy_ev}eV")
+        yield from set_energy_plan(
+            demand_energy_ev, cast(SetEnergyComposite, composite)
+        )
+
+        if doing_chi_change:
+            plan = _flyscan_plan_from_robot_load_params(composite, parameters)
+            LOGGER.info("Pin already loaded but chi changed so centring")
+        else:
+            LOGGER.info("Pin already loaded and chi not changed so doing nothing")
+            return
 
     detector_params = yield from fill_in_energy_if_not_supplied(
         composite.dcm, parameters.detector_params

mx_bluesky/hyperion/experiment_plans/rotation_scan_plan.py

@@ -4,7 +4,9 @@ import dataclasses
 
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
-from blueapi.core import BlueskyContext, MsgGenerator
+import pydantic
+from blueapi.core import BlueskyContext
+from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.backlight import Backlight
@@ -22,7 +24,7 @@ from dodal.devices.undulator import Undulator
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra import RotationDirection, Zebra
 from dodal.devices.zebra_controlled_shutter import ZebraShutter
-from dodal.plans.check_topup import check_topup_and_wait_if_necessary
+from dodal.plan_stubs.check_topup import check_topup_and_wait_if_necessary
 
 from mx_bluesky.common.device_setup_plans.read_hardware_for_setup import (
     read_hardware_for_zocalo,
@@ -62,7 +64,7 @@ from mx_bluesky.hyperion.parameters.rotation import (
 from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class RotationScanComposite(OavSnapshotComposite):
     """All devices which are directly or indirectly required by this plan"""
 
@@ -409,6 +411,11 @@ def multi_rotation_scan(
         }
     )
     @bpp.stage_decorator([eiger])
+    @transmission_and_xbpm_feedback_for_collection_decorator(
+        composite.xbpm_feedback,
+        composite.attenuator,
+        parameters.transmission_frac,
+    )
     @bpp.finalize_decorator(lambda: _cleanup_plan(composite))
     def _multi_rotation_scan():
         for single_scan in parameters.single_rotation_scans:
@@ -418,6 +425,7 @@ def multi_rotation_scan(
                 md={
                     "subplan_name": CONST.PLAN.ROTATION_OUTER,
                     CONST.TRIGGER.ZOCALO: CONST.PLAN.ROTATION_MAIN,
+                    "zocalo_environment": CONST.ZOCALO_ENV,
                     "hyperion_parameters": single_scan.model_dump_json(),
                 }
             )

mx_bluesky/hyperion/experiment_plans/set_energy_plan.py

@@ -5,8 +5,7 @@
 * reenable feedback
 """
 
-import dataclasses
-
+import pydantic
 from bluesky import plan_stubs as bps
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.dcm import DCM
@@ -24,7 +23,7 @@ DESIRED_TRANSMISSION_FRACTION = 0.1
 UNDULATOR_GROUP = "UNDULATOR_GROUP"
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class SetEnergyComposite:
     vfm: FocusingMirrorWithStripes
     mirror_voltages: MirrorVoltages
@@ -49,12 +48,13 @@ def _set_energy_plan(
 
 
 def set_energy_plan(
-    energy_kev,
+    energy_ev: float | None,
     composite: SetEnergyComposite,
 ):
-    yield from transmission_and_xbpm_feedback_for_collection_wrapper(
-        _set_energy_plan(energy_kev, composite),
-        composite.xbpm_feedback,
-        composite.attenuator,
-        DESIRED_TRANSMISSION_FRACTION,
-    )
+    if energy_ev:
+        yield from transmission_and_xbpm_feedback_for_collection_wrapper(
+            _set_energy_plan(energy_ev / 1000, composite),
+            composite.xbpm_feedback,
+            composite.attenuator,
+            DESIRED_TRANSMISSION_FRACTION,
+        )

mx_bluesky/hyperion/external_interaction/callbacks/__init__.py

@@ -4,7 +4,3 @@ execution of an experimental plan.
 
 Callbacks used for the Hyperion fast grid scan are prefixed with 'FGS'.
 """
-
-from .__main__ import main
-
-__all__ = ["main"]

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -20,6 +20,9 @@ from mx_bluesky.hyperion.external_interaction.callbacks.rotation.ispyb_callback
 from mx_bluesky.hyperion.external_interaction.callbacks.rotation.nexus_callback import (
     RotationNexusFileCallback,
 )
+from mx_bluesky.hyperion.external_interaction.callbacks.sample_handling.sample_handling_callback import (
+    SampleHandlingCallback,
+)
 from mx_bluesky.hyperion.external_interaction.callbacks.xray_centre.ispyb_callback import (
     GridscanISPyBCallback,
 )
@@ -49,6 +52,7 @@ def setup_callbacks():
         RotationISPyBCallback(emit=zocalo),
         LogUidTaggingCallback(),
         RobotLoadISPyBCallback(),
+        SampleHandlingCallback(),
     ]
 
 

mx_bluesky/hyperion/external_interaction/callbacks/common/abstract_event.py

@@ -0,0 +1,66 @@
+import builtins
+import dataclasses
+import time
+from abc import ABC
+from typing import Literal
+
+from bluesky.protocols import Readable, Reading
+from event_model import DataKey
+
+
+@dataclasses.dataclass(frozen=True)
+class AbstractEvent(Readable, ABC):
+    """An abstract superclass that can be extended to provide lightweight software events
+    for bluesky plans, without having to incur the overhead of creating ophyd-async devices
+    specifically for the purpose.
+
+    The currently supported types for field annotations in the event are ``str``, ``int``, ``float``, ``bool``
+
+    In future array types may be supported.
+
+    Examples:
+        Subclasses should extend this class and decorate with::
+
+            @dataclasses.dataclass(frozen=True)
+
+        To raise an event, simply construct the event and then ``read`` it as you would a device::
+
+            yield from bps.create("MY_EVENT_NAME")
+            my_event = MyEvent(an_int=1)
+            yield from bps.read(my_event)
+            yield from bps.save()
+    """
+
+    def read(self) -> dict[str, Reading]:
+        return {
+            f.name: AbstractEvent._reading_from_value(getattr(self, f.name))
+            for f in dataclasses.fields(self)
+        }
+
+    def describe(self) -> dict[str, DataKey]:
+        return {
+            f.name: DataKey(dtype=AbstractEvent._dtype_of(f.type), shape=[], source="")
+            for f in dataclasses.fields(self)
+        }
+
+    @classmethod
+    def _reading_from_value(cls, value):
+        return Reading(timestamp=time.time(), value=value)
+
+    @classmethod
+    def _dtype_of(cls, t) -> Literal["string", "number", "boolean", "integer"]:
+        match t:
+            case builtins.str:
+                return "string"
+            case builtins.bool:
+                return "boolean"
+            case builtins.int:
+                return "integer"
+            case builtins.float:
+                return "number"
+        # TODO array support
+        raise ValueError(f"Unsupported type for AbstractEvent: {t}")
+
+    @property
+    def name(self) -> str:
+        return type(self).__name__

mx_bluesky/hyperion/external_interaction/callbacks/common/callback_util.py

@@ -11,6 +11,9 @@ from mx_bluesky.hyperion.external_interaction.callbacks.rotation.ispyb_callback
 from mx_bluesky.hyperion.external_interaction.callbacks.rotation.nexus_callback import (
     RotationNexusFileCallback,
 )
+from mx_bluesky.hyperion.external_interaction.callbacks.sample_handling.sample_handling_callback import (
+    SampleHandlingCallback,
+)
 from mx_bluesky.hyperion.external_interaction.callbacks.xray_centre.ispyb_callback import (
     GridscanISPyBCallback,
 )
@@ -53,6 +56,7 @@ def create_load_centre_collect_callbacks() -> (
         RobotLoadISPyBCallback,
         RotationNexusFileCallback,
         RotationISPyBCallback,
+        SampleHandlingCallback,
     ]
 ):
     return (
@@ -61,4 +65,5 @@ def create_load_centre_collect_callbacks() -> (
         RobotLoadISPyBCallback(),
         RotationNexusFileCallback(),
         RotationISPyBCallback(emit=ZocaloCallback()),
+        SampleHandlingCallback(),
     )

mx_bluesky/hyperion/external_interaction/callbacks/grid_detection_callback.py

@@ -28,7 +28,7 @@ class GridDetectionCallback(CallbackBase):
         *args,
     ) -> None:
         super().__init__(*args)
-        self.start_positions: list = []
+        self.start_positions_mm: list = []
         self.box_numbers: list = []
 
     def event(self, doc: Event):
@@ -55,16 +55,16 @@ class GridDetectionCallback(CallbackBase):
         beam_x = data["oav-beam_centre_i"]
         beam_y = data["oav-beam_centre_j"]
 
-        position_grid_start = calculate_x_y_z_of_pixel(
+        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}")
+        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"],
@@ -72,22 +72,22 @@ class GridDetectionCallback(CallbackBase):
             )
         )
 
-        self.x_step_size_mm = box_width_px * microns_per_pixel_x / 1000
-        self.y_step_size_mm = box_width_px * microns_per_pixel_y / 1000
-        self.z_step_size_mm = box_width_px * microns_per_pixel_y / 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/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)
 
@@ -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

@@ -61,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)

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,8 +5,8 @@ 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 bluesky.utils import MsgGenerator
 from dodal.devices.zocalo.zocalo_results import (
     ZOCALO_READING_PLAN_NAME,
     get_processing_results_from_event,
@@ -53,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,
     )
 
 
@@ -98,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)
 
@@ -152,6 +157,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         ISPYB_LOGGER.info(
             f"Amending comment based on Zocalo reading doc: {format_doc_for_log(doc)}"
         )
+
         raw_results = get_processing_results_from_event("zocalo", doc)
         if len(raw_results) > 0:
             for n, res in enumerate(raw_results):