mx-bluesky 1.4.6__py3-none-any.whl → 1.4.8__py3-none-any.whl

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/{hyperion → common}/experiment_plans/change_aperture_then_move_plan.py

@@ -1,37 +1,31 @@
 import bluesky.plan_stubs as bps
-import bluesky.preprocessors as bpp
 import numpy
 from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
 from dodal.devices.smargon import Smargon, StubPosition
 
+from mx_bluesky.common.device_setup_plans.manipulate_sample import move_x_y_z
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.utils.tracing import TRACER
 from mx_bluesky.common.xrc_result import XRayCentreResult
-from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import move_x_y_z
-from mx_bluesky.hyperion.parameters.gridscan import HyperionSpecifiedThreeDGridScan
 
 
 def change_aperture_then_move_to_xtal(
     best_hit: XRayCentreResult,
     smargon: Smargon,
     aperture_scatterguard: ApertureScatterguard,
-    parameters: HyperionSpecifiedThreeDGridScan | None = None,
+    set_stub_offsets: bool | None = None,
 ):
     """For the given x-ray centring result,
     * Change the aperture so that the beam size is comparable to the crystal size
     * Centre on the centre-of-mass
     * Reset the stub offsets if specified by params"""
-    if best_hit.bounding_box_mm is not None:
-        bounding_box_size = numpy.abs(
-            best_hit.bounding_box_mm[1] - best_hit.bounding_box_mm[0]
-        )
-        with TRACER.start_span("change_aperture"):
-            yield from set_aperture_for_bbox_mm(
-                aperture_scatterguard,
-                bounding_box_size,
-            )
-    else:
-        LOGGER.warning("No bounding box size received")
+    bounding_box_size = numpy.abs(
+        best_hit.bounding_box_mm[1] - best_hit.bounding_box_mm[0]
+    )
+    yield from set_aperture_for_bbox_mm(
+        aperture_scatterguard,
+        bounding_box_size,
+    )
 
     # once we have the results, go to the appropriate position
     LOGGER.info("Moving to centre of mass.")
@@ -41,7 +35,7 @@ def change_aperture_then_move_to_xtal(
 
     # TODO support for setting stub offsets in multipin
     # https://github.com/DiamondLightSource/mx-bluesky/issues/552
-    if parameters and parameters.FGS_params.set_stub_offsets:
+    if set_stub_offsets:
         LOGGER.info("Recentring smargon co-ordinate system to this point.")
         yield from bps.mv(smargon.stub_offsets, StubPosition.CURRENT_AS_CENTER)
 
@@ -52,12 +46,12 @@ def set_aperture_for_bbox_mm(
 ):
     """Sets aperture size based on bbox_size.
 
-    This function determines the aperture size needed to accomodate the bounding box
+    This function determines the aperture size needed to accommodate the bounding box
     of a crystal. The x-axis length of the bounding box is used, setting the aperture
     to Medium if this is less than 50um, and Large otherwise.
 
     Args:
-        aperture_device: The aperture scatter gaurd device we are controlling.
+        aperture_device: The aperture scatter guard device we are controlling.
         bbox_size_mm: The [x,y,z] lengths, in mm, of a bounding box
         containing a crystal. This describes (in no particular order):
         * The maximum width a crystal occupies
@@ -77,14 +71,4 @@ def set_aperture_for_bbox_mm(
         f"Setting aperture to {new_selected_aperture} based on bounding box size {bbox_size_mm}."
     )
 
-    @bpp.set_run_key_decorator("change_aperture")
-    @bpp.run_decorator(
-        md={
-            "subplan_name": "change_aperture",
-            "aperture_size": new_selected_aperture.value,
-        }
-    )
-    def set_aperture():
-        yield from bps.abs_set(aperture_device, new_selected_aperture)
-
-    yield from set_aperture()
+    yield from bps.abs_set(aperture_device.selected_aperture, new_selected_aperture)

mx_bluesky/{hyperion → common}/experiment_plans/oav_grid_detection_plan.py

@@ -14,13 +14,13 @@ from dodal.devices.oav.pin_image_recognition.utils import NONE_VALUE
 from dodal.devices.oav.utils import PinNotFoundException, wait_for_tip_to_be_found
 from dodal.devices.smargon import Smargon
 
+from mx_bluesky.common.device_setup_plans.setup_oav import (
+    pre_centring_setup_oav,
+)
+from mx_bluesky.common.parameters.constants import DocDescriptorNames, HardwareConstants
 from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.exceptions import catch_exception_and_warn
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.device_setup_plans.setup_oav import (
-    pre_centring_setup_oav,
-)
-from mx_bluesky.hyperion.parameters.constants import CONST
 
 if TYPE_CHECKING:
     from dodal.devices.oav.oav_parameters import OAVParameters
@@ -103,7 +103,7 @@ def grid_detection_plan(
         yield from bps.mv(smargon.omega, angle)
         # need to wait for the OAV image to update
         # See #673 for improvements
-        yield from bps.sleep(CONST.HARDWARE.OAV_REFRESH_DELAY)
+        yield from bps.sleep(HardwareConstants.OAV_REFRESH_DELAY)
 
         tip_x_px, tip_y_px = yield from catch_exception_and_warn(
             PinNotFoundException, wait_for_tip_to_be_found, pin_tip_detection
@@ -163,7 +163,7 @@ def grid_detection_plan(
         yield from bps.abs_set(oav.grid_snapshot.filename, snapshot_filename)
         yield from bps.abs_set(oav.grid_snapshot.directory, snapshot_dir)
         yield from bps.trigger(oav.grid_snapshot, wait=True)
-        yield from bps.create(CONST.DESCRIPTORS.OAV_GRID_SNAPSHOT_TRIGGERED)
+        yield from bps.create(DocDescriptorNames.OAV_GRID_SNAPSHOT_TRIGGERED)
 
         yield from bps.read(oav)
         yield from bps.read(smargon)

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

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from collections.abc import Callable, Sequence
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 from dodal.beamline_specific_utils.i03 import beam_size_from_aperture
@@ -26,7 +27,7 @@ from mx_bluesky.common.external_interaction.ispyb.ispyb_store import (
 )
 from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import get_ispyb_config
 from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
-from mx_bluesky.common.parameters.constants import DocDescriptorNames, SimConstants
+from mx_bluesky.common.parameters.constants import DocDescriptorNames
 from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER, set_dcgid_tag
 from mx_bluesky.common.utils.utils import convert_eV_to_angstrom
 
@@ -70,10 +71,10 @@ class BaseISPyBCallback(PlanReactiveCallback):
         self.ispyb: StoreInIspyb
         self.descriptors: dict[str, EventDescriptor] = {}
         self.ispyb_config = get_ispyb_config()
-        if (
-            self.ispyb_config == SimConstants.ISPYB_CONFIG
-            or self.ispyb_config == SimConstants.DEV_ISPYB_DATABASE_CFG
-        ):
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info(
+            f"Using ISPyB configuration from {self.ispyb_config}"
+        )
+        if not self.ispyb_config or not Path(self.ispyb_config).is_absolute():
             ISPYB_ZOCALO_CALLBACK_LOGGER.warning(
                 f"{self.__class__} using dev ISPyB config: {self.ispyb_config}. If you"
                 "want to use the real database, please set the ISPYB_CONFIG_PATH "
@@ -121,10 +122,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/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,12 +15,15 @@ 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 and self.active:
             sample_id = doc.get("metadata", {}).get("sample_id")
@@ -30,6 +33,7 @@ class SampleHandlingCallback(PlanReactiveCallback):
 
     def activity_gated_stop(self, doc: RunStop) -> RunStop:
         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", "")
@@ -37,13 +41,17 @@ class SampleHandlingCallback(PlanReactiveCallback):
                 self.log.info(
                     f"Sample handling callback intercepted exception of type {exception_type}: {message}"
                 )
-                self._record_exception(exception_type)
+                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)
@@ -53,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

@@ -4,13 +4,8 @@ from collections.abc import Callable, Sequence
 from time import time
 from typing import TYPE_CHECKING, Any, TypeVar
 
-import numpy as np
 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,
-)
+from bluesky.utils import MsgGenerator, make_decorator
 
 from mx_bluesky.common.external_interaction.callbacks.common.ispyb_callback_base import (
     BaseISPyBCallback,
@@ -19,9 +14,6 @@ from mx_bluesky.common.external_interaction.callbacks.common.ispyb_mapping impor
     populate_data_collection_group,
     populate_remaining_data_collection_info,
 )
-from mx_bluesky.common.external_interaction.callbacks.common.logging_callback import (
-    format_doc_for_log,
-)
 from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_mapping import (
     construct_comment_for_gridscan,
     populate_xy_data_collection_info,
@@ -29,6 +21,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 +45,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,7 +63,7 @@ def ispyb_activation_wrapper(plan_generator: MsgGenerator, parameters):
     )
 
 
-T = TypeVar("T", bound="GridCommon")
+ispyb_activation_decorator = make_decorator(ispyb_activation_wrapper)
 
 
 class GridscanISPyBCallback(BaseISPyBCallback):
@@ -97,10 +93,12 @@ 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:
             self._start_of_fgs_uid = doc.get("uid")
+
         if doc.get("subplan_name") == PlanNameConstants.GRID_DETECT_AND_DO_GRIDSCAN:
             self.uid_to_finalize_on = doc.get("uid")
             ISPYB_ZOCALO_CALLBACK_LOGGER.info(
@@ -111,7 +109,9 @@ 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(
@@ -135,56 +135,37 @@ 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")
-        if descriptor_name == ZOCALO_READING_PLAN_NAME:
-            self._handle_zocalo_read_event(doc)
-        elif descriptor_name == DocDescriptorNames.OAV_GRID_SNAPSHOT_TRIGGERED:
+        if descriptor_name == DocDescriptorNames.OAV_GRID_SNAPSHOT_TRIGGERED:
             scan_data_infos = self._handle_oav_grid_snapshot_triggered(doc)
             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):
-        crystal_summary = ""
-        if self._processing_start_time is not None:
-            proc_time = time() - self._processing_start_time
-            crystal_summary = f"Zocalo processing took {proc_time:.2f} s. "
-        bboxes: list[np.ndarray] = []
-        ISPYB_ZOCALO_CALLBACK_LOGGER.info(
-            f"Amending comment based on Zocalo reading doc: {format_doc_for_log(doc)}"
-        )
+    def _add_processing_time_to_comment(self, processing_start_time: float):
+        assert self.data_collection_group_info, ASSERT_START_BEFORE_EVENT_DOC_MESSAGE
+        proc_time = time() - processing_start_time
+        crystal_summary = f"Zocalo processing took {proc_time:.2f} s."
+
+        self.data_collection_group_info.comments = (
+            self.data_collection_group_info.comments or ""
+        ) + crystal_summary
 
-        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"]
-                diff = np.array(bb[1]) - np.array(bb[0])
-                bboxes.append(diff)
-
-                nicely_formatted_com = [
-                    f"{np.round(com, 2)}" for com in res["centre_of_mass"]
-                ]
-                crystal_summary += (
-                    f"Crystal {n + 1}: "
-                    f"Strength {res['total_count']}; "
-                    f"Position (grid boxes) {nicely_formatted_com}; "
-                    f"Size (grid boxes) {bboxes[n]}; "
-                )
-        else:
-            crystal_summary += "Zocalo found no crystals in this gridscan."
-        assert self.ispyb_ids.data_collection_ids, (
-            "No data collection to add results to"
-        )
         self.ispyb.append_to_comment(
             self.ispyb_ids.data_collection_ids[0], crystal_summary
         )
@@ -192,6 +173,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 +202,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 +269,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 +286,13 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             )
             if exception_type:
                 doc["reason"] = message
+                self.data_collection_group_info.comments = message
+            elif self._processing_start_time:
+                self._add_processing_time_to_comment(self._processing_start_time)
+            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/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/ispyb_store.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 
 import ispyb
 import ispyb.sqlalchemy
+import numpy as np
 from ispyb.connector.mysqlsp.main import ISPyBMySQLSPConnector as Connector
 from ispyb.sp.mxacquisition import MXAcquisition
 from ispyb.strictordereddict import StrictOrderedDict
@@ -77,7 +78,7 @@ class StoreInIspyb:
         scan_data_infos,
     ) -> IspybIds:
         with ispyb.open(self.ISPYB_CONFIG_PATH) as conn:
-            assert conn is not None, "Failed to connect to ISPyB"
+            assert conn, "Failed to connect to ISPyB"
             if data_collection_group_info:
                 ispyb_ids.data_collection_group_id = (
                     self._store_data_collection_group_table(
@@ -152,6 +153,19 @@ class StoreInIspyb:
                 data_collection_id, comment, delimiter
             )
 
+    def update_data_collection_group_table(
+        self,
+        dcg_info: DataCollectionGroupInfo,
+        data_collection_group_id: int | None = None,
+    ) -> None:
+        with ispyb.open(self.ISPYB_CONFIG_PATH) as conn:
+            assert conn is not None, "Failed to connect to ISPyB!"
+            self._store_data_collection_group_table(
+                conn,
+                dcg_info,
+                data_collection_group_id,
+            )
+
     def _update_scan_with_end_time_and_status(
         self,
         end_time: str,
@@ -267,7 +281,9 @@ class StoreInIspyb:
                 conn, data_collection_info.visit_string
             )
         params |= {
-            k: v for k, v in asdict(data_collection_info).items() if k != "visit_string"
+            k: v.item() if isinstance(v, np.generic) else v  # Convert to native types
+            for k, v in asdict(data_collection_info).items()
+            if k != "visit_string"
         }
 
         return params

mx_bluesky/common/external_interaction/ispyb/ispyb_utils.py

@@ -7,11 +7,11 @@ from ispyb import NoResult
 from ispyb.connector.mysqlsp.main import ISPyBMySQLSPConnector as Connector
 from ispyb.sp.core import Core
 
-from mx_bluesky.common.parameters.constants import SimConstants
 
-
-def get_ispyb_config():
-    return os.environ.get("ISPYB_CONFIG_PATH", SimConstants.ISPYB_CONFIG)
+def get_ispyb_config() -> str:
+    ispyb_config = os.environ.get("ISPYB_CONFIG_PATH")
+    assert ispyb_config, "ISPYB_CONFIG_PATH must be set"
+    return ispyb_config
 
 
 def get_session_id_from_visit(conn: Connector, visit: str):

mx_bluesky/common/external_interaction/nexus/nexus_utils.py

@@ -144,7 +144,7 @@ def create_detector_parameters(detector_params: DetectorParams) -> Detector:
         list(
             detector_params.get_beam_position_pixels(detector_params.detector_distance)
         ),
-        detector_params.exposure_time,
+        detector_params.exposure_time_s,
         [(-1.0, 0.0, 0.0), (0.0, -1.0, 0.0)],
     )