mx-bluesky 1.4.5__py3-none-any.whl → 1.4.7__py3-none-any.whl

mx_bluesky/beamlines/i24/serial/setup_beamline/setup_zebra_plans.py

@@ -55,12 +55,12 @@ def get_zebra_settings_for_extruder(
 
 
 def arm_zebra(zebra: Zebra):
-    yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)
     SSX_LOGGER.info("Zebra armed.")
 
 
 def disarm_zebra(zebra: Zebra):
-    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, wait=True)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, wait=True)
     SSX_LOGGER.info("Zebra disarmed.")
 
 
@@ -272,7 +272,7 @@ def setup_zebra_for_fastchip_plan(
     det_type: str,
     num_gates: int,
     num_exposures: int,
-    exposure_time: float,
+    exposure_time_s: float,
     start_time_offset: float = 0.0,
     group: str = "setup_zebra_for_fastchip",
     wait: bool = True,
@@ -303,7 +303,7 @@ def setup_zebra_for_fastchip_plan(
         det_type (str): Detector in use, current choices are Eiger or Pilatus.
         num_gates (int): Number of apertures to visit in a chip.
         num_exposures (int): Number of times data is collected in each aperture.
-        exposure_time (float): Exposure time for each shot.
+        exposure_time_s (float): Exposure time for each shot.
         start_time_offset (float): Delay on the start of the position compare. \
             Defaults to 0.0 (standard chip collection).
     """
@@ -341,10 +341,12 @@ def setup_zebra_for_fastchip_plan(
         )
 
     # Square wave - needs a small drop to make it work for eiger
-    pulse_width = exposure_time - 0.0001 if det_type == "eiger" else exposure_time / 2
+    pulse_width = (
+        exposure_time_s - 0.0001 if det_type == "eiger" else exposure_time_s / 2
+    )
 
     # 100us buffer needed to avoid missing some of the triggers
-    exptime_buffer = exposure_time + 0.0001
+    exptime_buffer = exposure_time_s + 0.0001
 
     # Number of gates is the number of windows collected
     yield from bps.abs_set(zebra.pc.num_gates, num_gates, group=group)
@@ -362,7 +364,7 @@ def setup_zebra_for_fastchip_plan(
 def open_fast_shutter_at_each_position_plan(
     zebra: Zebra,
     num_exposures: int,
-    exposure_time: float,
+    exposure_time_s: float,
     group: str = "fast_shutter_control",
     wait: bool = True,
 ):
@@ -384,7 +386,7 @@ def open_fast_shutter_at_each_position_plan(
     Args:
         zebra (Zebra): The zebra ophyd device.
         num_exposures (int): Number of times data is collected in each aperture.
-        exposure_time (float): Exposure time for each shot.
+        exposure_time_s (float): Exposure time for each shot.
     """
     SSX_LOGGER.info(
         "ZEBRA setup for fastchip collection with long delays between exposures."
@@ -395,7 +397,7 @@ def open_fast_shutter_at_each_position_plan(
         zebra.output.pulse_2.input, zebra.mapping.sources.PC_GATE, group=group
     )
     yield from bps.abs_set(zebra.output.pulse_2.delay, 0.0, group=group)
-    pulse2_width = num_exposures * exposure_time + SHUTTER_OPEN_TIME
+    pulse2_width = num_exposures * exposure_time_s + SHUTTER_OPEN_TIME
     yield from bps.abs_set(zebra.output.pulse_2.width, pulse2_width, group=group)
 
     # Fast shutter

mx_bluesky/beamlines/i24/serial/web_gui_plans/general_plans.py

@@ -0,0 +1,109 @@
+# from collections.abc import Sequence
+from typing import Literal
+
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+from blueapi.core import MsgGenerator
+from dodal.beamlines import i24
+
+from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import (
+    ChipType,
+    MappingType,
+    PumpProbeSetting,
+)
+from mx_bluesky.beamlines.i24.serial.fixed_target.i24ssx_moveonclick import (
+    _move_on_mouse_click_plan,
+)
+from mx_bluesky.beamlines.i24.serial.log import _read_visit_directory_from_file
+from mx_bluesky.beamlines.i24.serial.parameters import (
+    FixedTargetParameters,
+    get_chip_format,
+)
+from mx_bluesky.beamlines.i24.serial.setup_beamline import pv
+from mx_bluesky.beamlines.i24.serial.setup_beamline.ca import caput
+from mx_bluesky.beamlines.i24.serial.setup_beamline.pv_abstract import Eiger, Pilatus
+from mx_bluesky.beamlines.i24.serial.setup_beamline.setup_detector import (
+    _move_detector_stage,
+    get_detector_type,
+)
+
+
+@bpp.run_decorator()
+def gui_stage_move_on_click(position_px: tuple[int, int]) -> MsgGenerator:
+    oav = i24.oav()
+    pmac = i24.pmac()
+    yield from _move_on_mouse_click_plan(oav, pmac, position_px)
+
+
+@bpp.run_decorator()
+def gui_gonio_move_on_click(position_px: tuple[int, int]) -> MsgGenerator:
+    oav = i24.oav()
+    gonio = i24.vgonio()
+
+    x_pixels_per_micron = yield from bps.rd(oav.microns_per_pixel_x)
+    y_pixels_per_micron = yield from bps.rd(oav.microns_per_pixel_y)
+
+    x_um = position_px[0] * x_pixels_per_micron
+    y_um = position_px[1] * y_pixels_per_micron
+
+    # gonio is in mm?
+    yield from bps.mv(gonio.x, x_um / 1000, gonio.yh, y_um / 1000)  # type: ignore
+
+
+# See https://github.com/DiamondLightSource/mx-bluesky/issues/853
+@bpp.run_decorator()
+def gui_sleep(sec: int) -> MsgGenerator:
+    for _ in range(sec):
+        yield from bps.sleep(1)
+
+
+@bpp.run_decorator()
+def gui_move_detector(det: Literal["eiger", "pilatus"]) -> MsgGenerator:
+    detector_stage = i24.detector_motion()
+    det_y_target = Eiger.det_y_target if det == "eiger" else Pilatus.det_y_target
+    yield from _move_detector_stage(detector_stage, det_y_target)
+    # Make the output readable
+    caput(pv.me14e_gp101, det)
+
+
+@bpp.run_decorator()
+def gui_set_parameters(
+    sub_dir: str,
+    chip_name: str,
+    exp_time: float,
+    det_dist: float,
+    transmission: float,
+    n_shots: int,
+    chip_type: str,
+    checker_pattern: bool,
+    pump_probe: str,
+    laser_dwell: float,
+    laser_delay: float,
+    pre_pump: float,
+) -> MsgGenerator:
+    # NOTE still a work in progress, adding to it as the ui grows
+    detector_stage = i24.detector_motion()
+    det_type = yield from get_detector_type(detector_stage)
+    chip_params = get_chip_format(ChipType[chip_type])
+
+    params = {
+        "visit": _read_visit_directory_from_file().as_posix(),  # noqa
+        "directory": sub_dir,
+        "filename": chip_name,
+        "exposure_time_s": exp_time,
+        "detector_distance_mm": det_dist,
+        "detector_name": str(det_type),
+        "num_exposures": n_shots,
+        "transmission": transmission,
+        "chip": chip_params,
+        "map_type": MappingType.NoMap,
+        "chip_map": [],
+        "pump_repeat": PumpProbeSetting[pump_probe],  # pump_repeat,
+        "laser_dwell_s": laser_dwell,
+        "laser_delay_s": laser_delay,
+        "checker_pattern": checker_pattern,
+        "pre_pump_exposure_s": pre_pump,
+    }
+    print(FixedTargetParameters(**params))
+    # This will then run the run_fixed_target plan
+    yield from bps.sleep(0.5)

mx_bluesky/beamlines/i24/serial/write_nexus.py

@@ -4,6 +4,7 @@ import pprint
 import time
 from datetime import datetime
 
+import bluesky.plan_stubs as bps
 import requests
 
 from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import ChipType, MappingType
@@ -12,7 +13,7 @@ from mx_bluesky.beamlines.i24.serial.parameters import (
     ExtruderParameters,
     FixedTargetParameters,
 )
-from mx_bluesky.beamlines.i24.serial.setup_beamline import Eiger, caget
+from mx_bluesky.beamlines.i24.serial.setup_beamline import Eiger, caget, cagetstring
 
 
 def call_nexgen(
@@ -53,7 +54,7 @@ def call_nexgen(
             total_numb_imgs = parameters.num_images
             pump_status = parameters.pump_status
 
-    filename_prefix = parameters.filename
+    filename_prefix = cagetstring(Eiger.pv.filenameRBV)
     meta_h5 = parameters.visit / parameters.directory / f"{filename_prefix}_meta.h5"
     t0 = time.time()
     max_wait = 60  # seconds
@@ -61,10 +62,10 @@ def call_nexgen(
     while time.time() - t0 < max_wait:
         if meta_h5.exists():
             SSX_LOGGER.info(f"Found {meta_h5} after {time.time() - t0:.1f} seconds")
-            time.sleep(5)
+            yield from bps.sleep(5)
             break
         SSX_LOGGER.debug(f"Waiting for {meta_h5}")
-        time.sleep(1)
+        yield from bps.sleep(1)
     if not meta_h5.exists():
         SSX_LOGGER.warning(f"Giving up waiting for {meta_h5} after {max_wait} seconds")
         return

mx_bluesky/common/device_setup_plans/xbpm_feedback.py

@@ -0,0 +1,45 @@
+from bluesky import plan_stubs as bps
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.xbpm_feedback import Pause, XBPMFeedback
+
+from mx_bluesky.common.utils.log import LOGGER
+
+
+def unpause_xbpm_feedback_and_set_transmission_to_1(
+    xbpm_feedback: XBPMFeedback, attenuator: BinaryFilterAttenuator
+):
+    """Turns the XBPM feedback back on and sets transmission to 1 so that it keeps the
+    beam aligned whilst not collecting.
+
+    Args:
+        xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
+                                      the beam in position
+        attenuator (BinaryFilterAttenuator): The attenuator used to set transmission
+    """
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+
+
+def check_and_pause_feedback(
+    xbpm_feedback: XBPMFeedback,
+    attenuator: BinaryFilterAttenuator,
+    desired_transmission_fraction: float,
+):
+    """Checks that the xbpm is in position before then turning it off and setting a new
+    transmission.
+
+    Args:
+        xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
+                                      the beam in position
+        attenuator (BinaryFilterAttenuator): The attenuator used to set transmission
+        desired_transmission_fraction (float): The desired transmission to set after
+                                               turning XBPM feedback off.
+
+    """
+    yield from bps.mv(attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    LOGGER.info("Waiting for XBPM feedback to be stable")
+    yield from bps.trigger(xbpm_feedback, wait=True)
+    LOGGER.info(
+        f"XPBM feedback in position, pausing and setting transmission to {desired_transmission_fraction}"
+    )
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.PAUSE)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.mv(attenuator, desired_transmission_fraction)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809

mx_bluesky/common/external_interaction/callbacks/common/ispyb_callback_base.py

@@ -121,10 +121,8 @@ class BaseISPyBCallback(PlanReactiveCallback):
         ISPYB_ZOCALO_CALLBACK_LOGGER.info(
             "ISPyB handler received event from read hardware"
         )
-        assert isinstance(
-            synchrotron_mode := doc["data"]["synchrotron-synchrotron_mode"],
-            SynchrotronMode,
-        )
+        synchrotron_mode = doc["data"]["synchrotron-synchrotron_mode"]
+        assert isinstance(synchrotron_mode, SynchrotronMode)
 
         hwscan_data_collection_info = DataCollectionInfo(
             undulator_gap1=doc["data"]["undulator-current_gap"],

mx_bluesky/common/external_interaction/callbacks/common/ispyb_mapping.py

@@ -35,7 +35,7 @@ def populate_remaining_data_collection_info(
     data_collection_info.detector_id = I03_EIGER_DETECTOR
     data_collection_info.comments = comment
     data_collection_info.detector_distance = params.detector_params.detector_distance
-    data_collection_info.exp_time = params.detector_params.exposure_time
+    data_collection_info.exp_time = params.detector_params.exposure_time_s
     data_collection_info.imgdir = params.detector_params.directory
     data_collection_info.imgprefix = params.detector_params.prefix
     data_collection_info.imgsuffix = EIGER_FILE_SUFFIX

mx_bluesky/common/external_interaction/callbacks/common/plan_reactive_callback.py

@@ -36,7 +36,7 @@ class PlanReactiveCallback(CallbackBase):
         super().__init__(emit=emit)
         self.emit_cb = emit  # to avoid GC; base class only holds a WeakRef
         self.active = False
-        self.activity_uid = 0
+        self.activity_uid = ""
         self.log = log
 
     def _run_activity_gated(self, name: str, func, doc, override=False):
@@ -76,7 +76,7 @@ class PlanReactiveCallback(CallbackBase):
         do_stop = self.active
         if doc.get("run_start") == self.activity_uid:
             self.active = False
-            self.activity_uid = 0
+            self.activity_uid = ""
         return (
             self._run_activity_gated(
                 "stop", self.activity_gated_stop, doc, override=True

mx_bluesky/common/external_interaction/callbacks/common/zocalo_callback.py

@@ -18,10 +18,11 @@ if TYPE_CHECKING:
 
 class ZocaloCallback(CallbackBase):
     """Callback class to handle the triggering of Zocalo processing.
-    Sends zocalo a run_start signal on receiving a start document for the specified
-    sub-plan, and sends a run_end signal on receiving a stop document for the same plan.
+    Will start listening for collections when {triggering_plan} has been started.
 
-    The metadata of the sub-plan this starts on must include a zocalo_environment.
+    For every ispyb deposition that occurs inside this run the callback will send zocalo
+    a run_start signal. Once the {triggering_plan} has ended the callback will send a
+    run_end signal for all collections.
 
     Shouldn't be subscribed directly to the RunEngine, instead should be passed to the
     `emit` argument of an ISPyB callback which appends DCIDs to the relevant start doc.
@@ -30,7 +31,9 @@ class ZocaloCallback(CallbackBase):
     def _reset_state(self):
         self.run_uid: str | None = None
         self.zocalo_info: list[ZocaloStartInfo] = []
+        self._started_zocalo_collections: list[ZocaloStartInfo] = []
         self.descriptors: dict[str, EventDescriptor] = {}
+        self.start_frame = 0
 
     def __init__(self, triggering_plan: str, zocalo_environment: str):
         super().__init__()
@@ -42,26 +45,21 @@ class ZocaloCallback(CallbackBase):
         ISPYB_ZOCALO_CALLBACK_LOGGER.info("Zocalo handler received start document.")
         if self.triggering_plan and doc.get("subplan_name") == self.triggering_plan:
             self.run_uid = doc.get("uid")
-            assert isinstance(scan_points := doc.get("scan_points"), list)
+        if self.run_uid:
             if (
-                isinstance(ispyb_ids := doc.get("ispyb_dcids"), tuple)
+                isinstance(scan_points := doc.get("scan_points"), list)
+                and isinstance(ispyb_ids := doc.get("ispyb_dcids"), tuple)
                 and len(ispyb_ids) > 0
             ):
                 ISPYB_ZOCALO_CALLBACK_LOGGER.info(f"Zocalo triggering for {ispyb_ids}")
                 ids_and_shape = list(zip(ispyb_ids, scan_points, strict=False))
-                start_frame = 0
-                self.zocalo_info = []
                 for idx, id_and_shape in enumerate(ids_and_shape):
                     id, shape = id_and_shape
                     num_frames = number_of_frames_from_scan_spec(shape)
                     self.zocalo_info.append(
-                        ZocaloStartInfo(id, None, start_frame, num_frames, idx)
+                        ZocaloStartInfo(id, None, self.start_frame, num_frames, idx)
                     )
-                    start_frame += num_frames
-            else:
-                raise ISPyBDepositionNotMade(
-                    f"No ISPyB IDs received by the start of {self.triggering_plan=}"
-                )
+                    self.start_frame += num_frames
 
     def descriptor(self, doc: EventDescriptor):
         self.descriptors[doc["uid"]] = doc
@@ -73,6 +71,8 @@ class ZocaloCallback(CallbackBase):
             for start_info in self.zocalo_info:
                 start_info.filename = filename
                 self.zocalo_interactor.run_start(start_info)
+                self._started_zocalo_collections.append(start_info)
+            self.zocalo_info = []
         return doc
 
     def stop(self, doc: RunStop):
@@ -80,7 +80,10 @@ class ZocaloCallback(CallbackBase):
             ISPYB_ZOCALO_CALLBACK_LOGGER.info(
                 f"Zocalo handler received stop document, for run {doc.get('run_start')}."
             )
-            assert self.zocalo_interactor is not None
-            for info in self.zocalo_info:
+            if not self._started_zocalo_collections:
+                raise ISPyBDepositionNotMade(
+                    f"No ISPyB IDs received by the end of {self.triggering_plan=}"
+                )
+            for info in self._started_zocalo_collections:
                 self.zocalo_interactor.run_end(info.ispyb_dcid)
             self._reset_state()

mx_bluesky/{hyperion → common}/external_interaction/callbacks/sample_handling/sample_handling_callback.py

@@ -15,30 +15,43 @@ class SampleHandlingCallback(PlanReactiveCallback):
     """Intercepts exceptions from experiment plans and updates the ISPyB BLSampleStatus
     field according to the type of exception raised."""
 
-    def __init__(self):
+    def __init__(self, record_loaded_on_success=False):
         super().__init__(log=ISPYB_ZOCALO_CALLBACK_LOGGER)
         self._sample_id: int | None = None
         self._descriptor: str | None = None
+        self._run_id: str | None = None
+
+        # Record 'sample loaded' if document successfully stops
+        self.record_loaded_on_success = record_loaded_on_success
 
     def activity_gated_start(self, doc: RunStart):
-        if not self._sample_id:
+        if not self._sample_id and self.active:
             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
+            self._run_id = self.activity_uid
 
     def activity_gated_stop(self, doc: RunStop) -> RunStop:
-        if doc["exit_status"] != "success":
-            exception_type, message = SampleException.type_and_message_from_reason(
-                doc.get("reason", "")
-            )
-            self.log.info(
-                f"Sample handling callback intercepted exception of type {exception_type}: {message}"
-            )
-            self._record_exception(exception_type)
+        if self._run_id == doc.get("run_start"):
+            expeye = ExpeyeInteraction()
+            if doc["exit_status"] != "success":
+                exception_type, message = SampleException.type_and_message_from_reason(
+                    doc.get("reason", "")
+                )
+                self.log.info(
+                    f"Sample handling callback intercepted exception of type {exception_type}: {message}"
+                )
+                self._record_exception(exception_type, expeye)
+
+            elif self.record_loaded_on_success:
+                self._record_loaded(expeye)
+
+            self._sample_id = None
+            self._run_id = None
+
         return doc
 
-    def _record_exception(self, exception_type: str):
-        expeye = ExpeyeInteraction()
+    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)
@@ -48,3 +61,7 @@ class SampleHandlingCallback(PlanReactiveCallback):
             case SampleException.__name__ | CrystalNotFoundException.__name__:
                 return BLSampleStatus.ERROR_SAMPLE
         return BLSampleStatus.ERROR_BEAMLINE
+
+    def _record_loaded(self, expeye: ExpeyeInteraction):
+        assert self._sample_id, "Unable to record loaded state due to no sample ID"
+        expeye.update_sample_status(self._sample_id, BLSampleStatus.LOADED)

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

@@ -29,6 +29,7 @@ from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_mapping
 )
 from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionGridInfo,
+    DataCollectionGroupInfo,
     DataCollectionInfo,
     DataCollectionPositionInfo,
     Orientation,
@@ -52,6 +53,9 @@ from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER, set_dcgid_
 if TYPE_CHECKING:
     from event_model import Event, RunStart, RunStop
 
+T = TypeVar("T", bound="GridCommon")
+ASSERT_START_BEFORE_EVENT_DOC_MESSAGE = f"No data collection group info - event document has been emitted before a {PlanNameConstants.GRID_DETECT_AND_DO_GRIDSCAN} start document"
+
 
 def ispyb_activation_wrapper(plan_generator: MsgGenerator, parameters):
     return bpp.set_run_key_wrapper(
@@ -67,9 +71,6 @@ def ispyb_activation_wrapper(plan_generator: MsgGenerator, parameters):
     )
 
 
-T = TypeVar("T", bound="GridCommon")
-
-
 class GridscanISPyBCallback(BaseISPyBCallback):
     """Callback class to handle the deposition of experiment parameters into the ISPyB
     database. Listens for 'event' and 'descriptor' documents. Creates the ISpyB entry on
@@ -97,6 +98,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         self.param_type = param_type
         self._start_of_fgs_uid: str | None = None
         self._processing_start_time: float | None = None
+        self.data_collection_group_info: DataCollectionGroupInfo | None
 
     def activity_gated_start(self, doc: RunStart):
         if doc.get("subplan_name") == PlanNameConstants.DO_FGS:
@@ -111,12 +113,14 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             assert isinstance(mx_bluesky_parameters, str)
             self.params = self.param_type.model_validate_json(mx_bluesky_parameters)
             self.ispyb = StoreInIspyb(self.ispyb_config)
-            data_collection_group_info = populate_data_collection_group(self.params)
+            self.data_collection_group_info = populate_data_collection_group(
+                self.params
+            )
 
             scan_data_infos = [
                 ScanDataInfo(
                     data_collection_info=populate_remaining_data_collection_info(
-                        None,
+                        "MX-Bluesky: Xray centring 1 -",
                         None,
                         populate_xy_data_collection_info(
                             self.params.detector_params,
@@ -126,7 +130,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
                 ),
                 ScanDataInfo(
                     data_collection_info=populate_remaining_data_collection_info(
-                        None,
+                        "MX-Bluesky: Xray centring 2 -",
                         None,
                         populate_xz_data_collection_info(self.params.detector_params),
                         self.params,
@@ -135,12 +139,13 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             ]
 
             self.ispyb_ids = self.ispyb.begin_deposition(
-                data_collection_group_info, scan_data_infos
+                self.data_collection_group_info, scan_data_infos
             )
             set_dcgid_tag(self.ispyb_ids.data_collection_group_id)
         return super().activity_gated_start(doc)
 
     def activity_gated_event(self, doc: Event):
+        assert self.data_collection_group_info, ASSERT_START_BEFORE_EVENT_DOC_MESSAGE
         doc = super().activity_gated_event(doc)
 
         descriptor_name = self.descriptors[doc["descriptor"]].get("name")
@@ -151,10 +156,14 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             self.ispyb_ids = self.ispyb.update_deposition(
                 self.ispyb_ids, scan_data_infos
             )
+        self.ispyb.update_data_collection_group_table(
+            self.data_collection_group_info, self.ispyb_ids.data_collection_group_id
+        )
 
         return doc
 
     def _handle_zocalo_read_event(self, doc):
+        assert self.data_collection_group_info, ASSERT_START_BEFORE_EVENT_DOC_MESSAGE
         crystal_summary = ""
         if self._processing_start_time is not None:
             proc_time = time() - self._processing_start_time
@@ -185,6 +194,11 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         assert self.ispyb_ids.data_collection_ids, (
             "No data collection to add results to"
         )
+
+        self.data_collection_group_info.comments = (
+            self.data_collection_group_info.comments or ""
+        ) + crystal_summary
+
         self.ispyb.append_to_comment(
             self.ispyb_ids.data_collection_ids[0], crystal_summary
         )
@@ -192,6 +206,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
     def _handle_oav_grid_snapshot_triggered(self, doc) -> Sequence[ScanDataInfo]:
         assert self.ispyb_ids.data_collection_ids, "No current data collection"
         assert self.params, "ISPyB handler didn't receive parameters!"
+        assert self.data_collection_group_info, "No data collection group"
         data = doc["data"]
         data_collection_id = None
         data_collection_info = DataCollectionInfo(
@@ -220,6 +235,18 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         data_collection_info.comments = construct_comment_for_gridscan(
             data_collection_grid_info
         )
+
+        if self.data_collection_group_info.comments:
+            self.data_collection_group_info.comments += (
+                f"by {data_collection_grid_info.steps_y}."
+            )
+        else:
+            self.data_collection_group_info.comments = (
+                f"Diffraction grid scan of "
+                f"{data_collection_grid_info.steps_x} "
+                f"by {data_collection_grid_info.steps_y} "
+            )
+
         if len(self.ispyb_ids.data_collection_ids) > self._oav_snapshot_event_idx:
             data_collection_id = self.ispyb_ids.data_collection_ids[
                 self._oav_snapshot_event_idx
@@ -275,6 +302,9 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         return scan_data_infos
 
     def activity_gated_stop(self, doc: RunStop) -> RunStop:
+        assert self.data_collection_group_info, (
+            f"No data collection group info - stop document has been emitted before a {PlanNameConstants.GRID_DETECT_AND_DO_GRIDSCAN} start document"
+        )
         if doc.get("run_start") == self._start_of_fgs_uid:
             self._processing_start_time = time()
         if doc.get("run_start") == self.uid_to_finalize_on:
@@ -289,5 +319,11 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             )
             if exception_type:
                 doc["reason"] = message
+                self.data_collection_group_info.comments = message
+                self.ispyb.update_data_collection_group_table(
+                    self.data_collection_group_info,
+                    self.ispyb_ids.data_collection_group_id,
+                )
+            self.data_collection_group_info = None
             return super().activity_gated_stop(doc)
         return self._tag_doc(doc)

mx_bluesky/common/external_interaction/callbacks/xray_centre/ispyb_mapping.py

@@ -43,7 +43,7 @@ def construct_comment_for_gridscan(grid_info: DataCollectionGridInfo) -> str:
         grid_info.microns_per_pixel_y,
     )
     return (
-        "MX-Bluesky: Xray centring - Diffraction grid scan of "
+        "Diffraction grid scan of "
         f"{grid_info.steps_x} by "
         f"{grid_info.steps_y} images in "
         f"{(grid_info.dx_in_mm * 1e3):.1f} um by "

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

@@ -79,7 +79,8 @@ class GridscanNexusFileCallback(PlanReactiveCallback):
         self.descriptors[doc["uid"]] = doc
 
     def activity_gated_event(self, doc: Event) -> Event | None:
-        assert (event_descriptor := self.descriptors.get(doc["descriptor"])) is not None
+        event_descriptor = self.descriptors.get(doc["descriptor"])
+        assert event_descriptor is not None
         if event_descriptor.get("name") == DocDescriptorNames.HARDWARE_READ_DURING:
             data = doc["data"]
             for nexus_writer in [self.nexus_writer_1, self.nexus_writer_2]:

mx_bluesky/common/external_interaction/ispyb/data_model.py

@@ -13,6 +13,7 @@ class DataCollectionGroupInfo:
     experiment_type: str
     sample_id: int | None
     sample_barcode: str | None = None
+    comments: str | None = None
 
 
 @dataclass(kw_only=True)

mx_bluesky/common/external_interaction/ispyb/exp_eye_store.py

@@ -2,7 +2,7 @@ import configparser
 from dataclasses import dataclass
 from enum import StrEnum
 
-from requests import patch, post
+from requests import JSONDecodeError, patch, post
 from requests.auth import AuthBase
 
 from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import (
@@ -34,7 +34,11 @@ def _get_base_url_and_token() -> tuple[str, str]:
 def _send_and_get_response(auth, url, data, send_func) -> dict:
     response = send_func(url, auth=auth, json=data)
     if not response.ok:
-        raise ISPyBDepositionNotMade(f"Could not write {data} to {url}: {response}")
+        try:
+            resp_txt = str(response.json())
+        except JSONDecodeError:
+            resp_txt = str(response)
+        raise ISPyBDepositionNotMade(f"Could not write {data} to {url}: {resp_txt}")
     return response.json()