mx-bluesky 1.4.2__py3-none-any.whl → 1.4.4__py3-none-any.whl

mx_bluesky/{hyperion/external_interaction/callbacks → common/external_interaction/callbacks/common}/ispyb_callback_base.py

@@ -9,26 +9,26 @@ 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 (
+from mx_bluesky.common.external_interaction.callbacks.common.logging_callback import (
+    format_doc_for_log,
+)
+from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
     PlanReactiveCallback,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.data_model import (
+from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionInfo,
     DataCollectionPositionInfo,
     ScanDataInfo,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
+from mx_bluesky.common.external_interaction.ispyb.ispyb_store import (
     IspybIds,
     StoreInIspyb,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_utils import get_ispyb_config
-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
-
-from .logging_callback import format_doc_for_log
+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.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER, set_dcgid_tag
+from mx_bluesky.common.utils.utils import convert_eV_to_angstrom
 
 D = TypeVar("D")
 if TYPE_CHECKING:
@@ -63,25 +63,25 @@ class BaseISPyBCallback(PlanReactiveCallback):
         """Subclasses should run super().__init__() with parameters, then set
         self.ispyb to the type of ispyb relevant to the experiment and define the type
         for self.ispyb_ids."""
-        ISPYB_LOGGER.debug("Initialising ISPyB callback")
-        super().__init__(log=ISPYB_LOGGER, emit=emit)
+        ISPYB_ZOCALO_CALLBACK_LOGGER.debug("Initialising ISPyB callback")
+        super().__init__(log=ISPYB_ZOCALO_CALLBACK_LOGGER, emit=emit)
         self._oav_snapshot_event_idx: int = 0
         self.params: DiffractionExperimentWithSample | None = None
         self.ispyb: StoreInIspyb
         self.descriptors: dict[str, EventDescriptor] = {}
         self.ispyb_config = get_ispyb_config()
         if (
-            self.ispyb_config == CONST.SIM.ISPYB_CONFIG
-            or self.ispyb_config == CONST.SIM.DEV_ISPYB_DATABASE_CFG
+            self.ispyb_config == SimConstants.ISPYB_CONFIG
+            or self.ispyb_config == SimConstants.DEV_ISPYB_DATABASE_CFG
         ):
-            ISPYB_LOGGER.warning(
+            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 "
                 "environment variable."
             )
         self.uid_to_finalize_on: str | None = None
         self.ispyb_ids: IspybIds = IspybIds()
-        self.log = ISPYB_LOGGER
+        self.log = ISPYB_ZOCALO_CALLBACK_LOGGER
 
     def activity_gated_start(self, doc: RunStart):
         self._oav_snapshot_event_idx = 0
@@ -94,31 +94,33 @@ class BaseISPyBCallback(PlanReactiveCallback):
     def activity_gated_event(self, doc: Event) -> Event:
         """Subclasses should extend this to add a call to set_dcig_tag from
         hyperion.log"""
-        ISPYB_LOGGER.debug("ISPyB handler received event document.")
+        ISPYB_ZOCALO_CALLBACK_LOGGER.debug("ISPyB handler received event document.")
         assert self.ispyb is not None, "ISPyB deposition wasn't initialised!"
         assert self.params is not None, "ISPyB handler didn't receive parameters!"
 
         event_descriptor = self.descriptors.get(doc["descriptor"])
         if event_descriptor is None:
-            ISPYB_LOGGER.warning(
+            ISPYB_ZOCALO_CALLBACK_LOGGER.warning(
                 f"Ispyb handler {self} received event doc {format_doc_for_log(doc)} and "
                 "has no corresponding descriptor record"
             )
             return doc
         match event_descriptor.get("name"):
-            case CONST.DESCRIPTORS.HARDWARE_READ_PRE:
+            case DocDescriptorNames.HARDWARE_READ_PRE:
                 scan_data_infos = self._handle_ispyb_hardware_read(doc)
-            case CONST.DESCRIPTORS.HARDWARE_READ_DURING:
+            case DocDescriptorNames.HARDWARE_READ_DURING:
                 scan_data_infos = self._handle_ispyb_transmission_flux_read(doc)
             case _:
                 return self._tag_doc(doc)
         self.ispyb_ids = self.ispyb.update_deposition(self.ispyb_ids, scan_data_infos)
-        ISPYB_LOGGER.info(f"Received ISPYB IDs: {self.ispyb_ids}")
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info(f"Received ISPYB IDs: {self.ispyb_ids}")
         return self._tag_doc(doc)
 
     def _handle_ispyb_hardware_read(self, doc) -> Sequence[ScanDataInfo]:
         assert self.params, "Event handled before activity_gated_start received params"
-        ISPYB_LOGGER.info("ISPyB handler received event from read hardware")
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info(
+            "ISPyB handler received event from read hardware"
+        )
         assert isinstance(
             synchrotron_mode := doc["data"]["synchrotron-synchrotron_mode"],
             SynchrotronMode,
@@ -127,8 +129,8 @@ class BaseISPyBCallback(PlanReactiveCallback):
         hwscan_data_collection_info = DataCollectionInfo(
             undulator_gap1=doc["data"]["undulator-current_gap"],
             synchrotron_mode=synchrotron_mode.value,
-            slitgap_horizontal=doc["data"]["s4_slit_gaps_xgap"],
-            slitgap_vertical=doc["data"]["s4_slit_gaps_ygap"],
+            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
@@ -141,7 +143,9 @@ class BaseISPyBCallback(PlanReactiveCallback):
         scan_data_infos = self.populate_info_for_update(
             hwscan_data_collection_info, hwscan_position_info, self.params
         )
-        ISPYB_LOGGER.info("Updating ispyb data collection after hardware read.")
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info(
+            "Updating ispyb data collection after hardware read."
+        )
         return scan_data_infos
 
     def _handle_ispyb_transmission_flux_read(self, doc) -> Sequence[ScanDataInfo]:
@@ -156,7 +160,7 @@ class BaseISPyBCallback(PlanReactiveCallback):
             beamsize_at_sampley=beamsize_y_mm,
             focal_spot_size_at_samplex=beamsize_x_mm,
             focal_spot_size_at_sampley=beamsize_y_mm,
-            flux=doc["data"]["flux_flux_reading"],
+            flux=doc["data"]["flux-flux_reading"],
         )
         if transmission := doc["data"]["attenuator-actual_transmission"]:
             # Ispyb wants the transmission in a percentage, we use fractions
@@ -167,7 +171,9 @@ class BaseISPyBCallback(PlanReactiveCallback):
         scan_data_infos = self.populate_info_for_update(
             hwscan_data_collection_info, None, self.params
         )
-        ISPYB_LOGGER.info("Updating ispyb data collection after flux read.")
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info(
+            "Updating ispyb data collection after flux read."
+        )
         self.append_to_comment(f"Aperture: {aperture}. ")
         return scan_data_infos
 
@@ -183,10 +189,10 @@ class BaseISPyBCallback(PlanReactiveCallback):
     def activity_gated_stop(self, doc: RunStop) -> RunStop:
         """Subclasses must check that they are recieving a stop document for the correct
         uid to use this method!"""
-        assert (
-            self.ispyb is not None
-        ), "ISPyB handler received stop document, but deposition object doesn't exist!"
-        ISPYB_LOGGER.debug("ISPyB handler received stop document.")
+        assert self.ispyb is not None, (
+            "ISPyB handler received stop document, but deposition object doesn't exist!"
+        )
+        ISPYB_ZOCALO_CALLBACK_LOGGER.debug("ISPyB handler received stop document.")
         exit_status = (
             doc.get("exit_status") or "Exit status not available in stop document!"
         )
@@ -195,7 +201,7 @@ class BaseISPyBCallback(PlanReactiveCallback):
         try:
             self.ispyb.end_deposition(self.ispyb_ids, exit_status, reason)
         except Exception as e:
-            ISPYB_LOGGER.warning(
+            ISPYB_ZOCALO_CALLBACK_LOGGER.warning(
                 f"Failed to finalise ISPyB deposition on stop document: {format_doc_for_log(doc)} with exception: {e}"
             )
         return self._tag_doc(doc)
@@ -205,7 +211,7 @@ class BaseISPyBCallback(PlanReactiveCallback):
         try:
             self.ispyb.append_to_comment(id, comment)
         except TypeError:
-            ISPYB_LOGGER.warning(
+            ISPYB_ZOCALO_CALLBACK_LOGGER.warning(
                 "ISPyB deposition not initialised, can't update comment."
             )
 

mx_bluesky/{hyperion → common}/external_interaction/callbacks/common/ispyb_mapping.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
-from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
-from mx_bluesky.hyperion.external_interaction.ispyb.data_model import (
+from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionGroupInfo,
     DataCollectionInfo,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
+from mx_bluesky.common.external_interaction.ispyb.ispyb_store import (
     EIGER_FILE_SUFFIX,
     I03_EIGER_DETECTOR,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_utils import (
+from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import (
     get_current_time_string,
 )
+from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
 
 
 def populate_data_collection_group(params: DiffractionExperimentWithSample):

mx_bluesky/{hyperion/external_interaction/callbacks → common/external_interaction/callbacks/common}/logging_callback.py

@@ -2,7 +2,7 @@ import json
 
 from bluesky.callbacks import CallbackBase
 
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 
 
 class _BestEffortEncoder(json.JSONEncoder):

mx_bluesky/{hyperion/external_interaction/callbacks → common/external_interaction/callbacks/common}/zocalo_callback.py

@@ -5,10 +5,12 @@ from typing import TYPE_CHECKING
 from bluesky.callbacks import CallbackBase
 from dodal.devices.zocalo import ZocaloStartInfo, ZocaloTrigger
 
-from mx_bluesky.hyperion.external_interaction.exceptions import ISPyBDepositionNotMade
-from mx_bluesky.hyperion.log import ISPYB_LOGGER
-from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.utils.utils import number_of_frames_from_scan_spec
+from mx_bluesky.common.parameters.constants import (
+    DocDescriptorNames,
+)
+from mx_bluesky.common.utils.exceptions import ISPyBDepositionNotMade
+from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER
+from mx_bluesky.common.utils.utils import number_of_frames_from_scan_spec
 
 if TYPE_CHECKING:
     from event_model.documents import Event, EventDescriptor, RunStart, RunStop
@@ -27,25 +29,17 @@ class ZocaloCallback(CallbackBase):
 
     def _reset_state(self):
         self.run_uid: str | None = None
-        self.triggering_plan: str | None = None
-        self.zocalo_interactor: ZocaloTrigger | None = None
         self.zocalo_info: list[ZocaloStartInfo] = []
         self.descriptors: dict[str, EventDescriptor] = {}
 
-    def __init__(
-        self,
-    ):
+    def __init__(self, triggering_plan: str, zocalo_environment: str):
         super().__init__()
+        self.triggering_plan = triggering_plan
+        self.zocalo_interactor = ZocaloTrigger(zocalo_environment)
         self._reset_state()
 
     def start(self, doc: RunStart):
-        ISPYB_LOGGER.info("Zocalo handler received start document.")
-        if triggering_plan := doc.get(CONST.TRIGGER.ZOCALO):
-            self.triggering_plan = triggering_plan
-            assert isinstance(zocalo_environment := doc.get("zocalo_environment"), str)
-            ISPYB_LOGGER.info(f"Zocalo environment set to {zocalo_environment}.")
-            self.zocalo_interactor = ZocaloTrigger(zocalo_environment)
-
+        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)
@@ -53,6 +47,7 @@ class ZocaloCallback(CallbackBase):
                 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 = []
@@ -73,17 +68,16 @@ class ZocaloCallback(CallbackBase):
 
     def event(self, doc: Event) -> Event:
         event_descriptor = self.descriptors[doc["descriptor"]]
-        if event_descriptor.get("name") == CONST.DESCRIPTORS.ZOCALO_HW_READ:
+        if event_descriptor.get("name") == DocDescriptorNames.ZOCALO_HW_READ:
             filename = doc["data"]["eiger_odin_file_writer_id"]
             for start_info in self.zocalo_info:
                 start_info.filename = filename
-                assert self.zocalo_interactor is not None
                 self.zocalo_interactor.run_start(start_info)
         return doc
 
     def stop(self, doc: RunStop):
         if doc.get("run_start") == self.run_uid:
-            ISPYB_LOGGER.info(
+            ISPYB_ZOCALO_CALLBACK_LOGGER.info(
                 f"Zocalo handler received stop document, for run {doc.get('run_start')}."
             )
             assert self.zocalo_interactor is not None

mx_bluesky/{hyperion → common}/external_interaction/callbacks/xray_centre/ispyb_callback.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable, Sequence
 from time import time
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, TypeVar
 
 import numpy as np
 from bluesky import preprocessors as bpp
@@ -12,41 +12,39 @@ from dodal.devices.zocalo.zocalo_results import (
     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 (
+from mx_bluesky.common.external_interaction.callbacks.common.ispyb_callback_base import (
+    BaseISPyBCallback,
+)
+from mx_bluesky.common.external_interaction.callbacks.common.ispyb_mapping import (
     populate_data_collection_group,
     populate_remaining_data_collection_info,
 )
-from mx_bluesky.hyperion.external_interaction.callbacks.ispyb_callback_base import (
-    BaseISPyBCallback,
-)
-from mx_bluesky.hyperion.external_interaction.callbacks.logging_callback import (
+from mx_bluesky.common.external_interaction.callbacks.common.logging_callback import (
     format_doc_for_log,
 )
-from mx_bluesky.hyperion.external_interaction.callbacks.xray_centre.ispyb_mapping import (
+from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_mapping import (
     construct_comment_for_gridscan,
     populate_xy_data_collection_info,
     populate_xz_data_collection_info,
 )
-from mx_bluesky.hyperion.external_interaction.exceptions import ISPyBDepositionNotMade
-from mx_bluesky.hyperion.external_interaction.ispyb.data_model import (
+from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionGridInfo,
     DataCollectionInfo,
     DataCollectionPositionInfo,
     Orientation,
     ScanDataInfo,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
+from mx_bluesky.common.external_interaction.ispyb.ispyb_store import (
     IspybIds,
     StoreInIspyb,
 )
-from mx_bluesky.hyperion.log import ISPYB_LOGGER
-from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.gridscan import (
+from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
+from mx_bluesky.common.parameters.constants import DocDescriptorNames, PlanNameConstants
+from mx_bluesky.common.parameters.gridscan import (
     GridCommon,
 )
+from mx_bluesky.common.utils.exceptions import ISPyBDepositionNotMade
+from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER, set_dcgid_tag
 
 if TYPE_CHECKING:
     from event_model import Event, RunStart, RunStop
@@ -58,14 +56,17 @@ def ispyb_activation_wrapper(plan_generator: MsgGenerator, parameters):
             plan_generator,
             md={
                 "activate_callbacks": ["GridscanISPyBCallback"],
-                "subplan_name": CONST.PLAN.GRID_DETECT_AND_DO_GRIDSCAN,
-                "hyperion_parameters": parameters.model_dump_json(),
+                "subplan_name": PlanNameConstants.GRID_DETECT_AND_DO_GRIDSCAN,
+                "mx_bluesky_parameters": parameters.model_dump_json(),
             },
         ),
-        CONST.PLAN.ISPYB_ACTIVATION,
+        PlanNameConstants.ISPYB_ACTIVATION,
     )
 
 
+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
@@ -83,27 +84,29 @@ class GridscanISPyBCallback(BaseISPyBCallback):
 
     def __init__(
         self,
+        param_type: type[T],
         *,
         emit: Callable[..., Any] | None = None,
     ) -> None:
         super().__init__(emit=emit)
         self.ispyb: StoreInIspyb
         self.ispyb_ids: IspybIds = IspybIds()
+        self.param_type = param_type
         self._start_of_fgs_uid: str | None = None
         self._processing_start_time: float | None = 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") == CONST.PLAN.GRID_DETECT_AND_DO_GRIDSCAN:
+        if doc.get("subplan_name") == PlanNameConstants.GRID_DETECT_AND_DO_GRIDSCAN:
             self.uid_to_finalize_on = doc.get("uid")
-            ISPYB_LOGGER.info(
+            ISPYB_ZOCALO_CALLBACK_LOGGER.info(
                 "ISPyB callback received start document with experiment parameters and "
                 f"uid: {self.uid_to_finalize_on}"
             )
-            hyperion_params = doc.get("hyperion_parameters")
-            assert isinstance(hyperion_params, str)
-            self.params = GridCommon.model_validate_json(hyperion_params)
+            mx_bluesky_parameters = doc.get("mx_bluesky_parameters")
+            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)
 
@@ -140,7 +143,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         descriptor_name = self.descriptors[doc["descriptor"]].get("name")
         if descriptor_name == ZOCALO_READING_PLAN_NAME:
             self._handle_zocalo_read_event(doc)
-        elif descriptor_name == CONST.DESCRIPTORS.OAV_GRID_SNAPSHOT_TRIGGERED:
+        elif 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
@@ -154,7 +157,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             proc_time = time() - self._processing_start_time
             crystal_summary = f"Zocalo processing took {proc_time:.2f} s. "
         bboxes: list[np.ndarray] = []
-        ISPYB_LOGGER.info(
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info(
             f"Amending comment based on Zocalo reading doc: {format_doc_for_log(doc)}"
         )
 
@@ -176,9 +179,9 @@ class GridscanISPyBCallback(BaseISPyBCallback):
                 )
         else:
             crystal_summary += "Zocalo found no crystals in this gridscan."
-        assert (
-            self.ispyb_ids.data_collection_ids
-        ), "No data collection to add results to"
+        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
         )
@@ -225,7 +228,9 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             data_collection_id=data_collection_id,
             data_collection_grid_info=data_collection_grid_info,
         )
-        ISPYB_LOGGER.info("Updating ispyb data collection after oav snapshot.")
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info(
+            "Updating ispyb data collection after oav snapshot."
+        )
         self._oav_snapshot_event_idx += 1
         return [scan_data_info]
 
@@ -245,9 +250,9 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         event_sourced_position_info: DataCollectionPositionInfo | None,
         params: DiffractionExperimentWithSample,
     ) -> Sequence[ScanDataInfo]:
-        assert (
-            self.ispyb_ids.data_collection_ids
-        ), "Expect at least one valid data collection to record scan data"
+        assert self.ispyb_ids.data_collection_ids, (
+            "Expect at least one valid data collection to record scan data"
+        )
         xy_scan_data_info = ScanDataInfo(
             data_collection_info=event_sourced_data_collection_info,
             data_collection_id=self.ispyb_ids.data_collection_ids[0],
@@ -270,7 +275,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         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:
-            ISPYB_LOGGER.info(
+            ISPYB_ZOCALO_CALLBACK_LOGGER.info(
                 "ISPyB callback received stop document corresponding to start document "
                 f"with uid: {self.uid_to_finalize_on}."
             )

mx_bluesky/{hyperion → common}/external_interaction/callbacks/xray_centre/ispyb_mapping.py

@@ -4,7 +4,7 @@ import numpy
 from dodal.devices.detector import DetectorParams
 from dodal.devices.oav import utils as oav_utils
 
-from mx_bluesky.hyperion.external_interaction.ispyb.data_model import (
+from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionGridInfo,
     DataCollectionInfo,
 )
@@ -43,7 +43,7 @@ def construct_comment_for_gridscan(grid_info: DataCollectionGridInfo) -> str:
         grid_info.microns_per_pixel_y,
     )
     return (
-        "Hyperion: Xray centring - Diffraction grid scan of "
+        "MX-Bluesky: Xray centring - 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/{hyperion → common}/external_interaction/callbacks/xray_centre/nexus_callback.py

@@ -1,22 +1,26 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeVar
 
-from mx_bluesky.hyperion.external_interaction.callbacks.plan_reactive_callback import (
+from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
     PlanReactiveCallback,
 )
-from mx_bluesky.hyperion.external_interaction.nexus.nexus_utils import (
+from mx_bluesky.common.external_interaction.nexus.nexus_utils import (
     create_beam_and_attenuator_parameters,
     vds_type_based_on_bit_depth,
 )
-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 HyperionThreeDGridScan
+from mx_bluesky.common.external_interaction.nexus.write_nexus import NexusWriter
+from mx_bluesky.common.parameters.constants import DocDescriptorNames, PlanNameConstants
+from mx_bluesky.common.parameters.gridscan import (
+    SpecifiedThreeDGridScan,
+)
+from mx_bluesky.common.utils.log import NEXUS_LOGGER
 
 if TYPE_CHECKING:
     from event_model.documents import Event, EventDescriptor, RunStart
 
+T = TypeVar("T", bound="SpecifiedThreeDGridScan")
+
 
 class GridscanNexusFileCallback(PlanReactiveCallback):
     """Callback class to handle the creation of Nexus files based on experiment \
@@ -35,8 +39,9 @@ class GridscanNexusFileCallback(PlanReactiveCallback):
     See: https://blueskyproject.io/bluesky/callbacks.html#ways-to-invoke-callbacks
     """
 
-    def __init__(self) -> None:
+    def __init__(self, param_type: type[T]) -> None:
         super().__init__(NEXUS_LOGGER)
+        self.param_type = param_type
         self.run_start_uid: str | None = None
         self.nexus_writer_1: NexusWriter | None = None
         self.nexus_writer_2: NexusWriter | None = None
@@ -44,13 +49,13 @@ class GridscanNexusFileCallback(PlanReactiveCallback):
         self.log = NEXUS_LOGGER
 
     def activity_gated_start(self, doc: RunStart):
-        if doc.get("subplan_name") == CONST.PLAN.GRIDSCAN_OUTER:
-            hyperion_params = doc.get("hyperion_parameters")
-            assert isinstance(hyperion_params, str)
+        if doc.get("subplan_name") == PlanNameConstants.GRIDSCAN_OUTER:
+            mx_bluesky_parameters = doc.get("mx_bluesky_parameters")
+            assert isinstance(mx_bluesky_parameters, str)
             NEXUS_LOGGER.info(
-                f"Nexus writer received start document with experiment parameters {hyperion_params}"
+                f"Nexus writer received start document with experiment parameters {mx_bluesky_parameters}"
             )
-            parameters = HyperionThreeDGridScan.model_validate_json(hyperion_params)
+            parameters = self.param_type.model_validate_json(mx_bluesky_parameters)
             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
@@ -75,7 +80,7 @@ class GridscanNexusFileCallback(PlanReactiveCallback):
 
     def activity_gated_event(self, doc: Event) -> Event | None:
         assert (event_descriptor := self.descriptors.get(doc["descriptor"])) is not None
-        if event_descriptor.get("name") == CONST.DESCRIPTORS.HARDWARE_READ_DURING:
+        if event_descriptor.get("name") == DocDescriptorNames.HARDWARE_READ_DURING:
             data = doc["data"]
             for nexus_writer in [self.nexus_writer_1, self.nexus_writer_2]:
                 assert nexus_writer, "Nexus callback did not receive start doc"
@@ -84,7 +89,7 @@ class GridscanNexusFileCallback(PlanReactiveCallback):
                     nexus_writer.attenuator,
                 ) = create_beam_and_attenuator_parameters(
                     data["dcm-energy_in_kev"],
-                    data["flux_flux_reading"],
+                    data["flux-flux_reading"],
                     data["attenuator-actual_transmission"],
                 )
                 vds_data_type = vds_type_based_on_bit_depth(

mx_bluesky/common/external_interaction/config_server.py

@@ -29,8 +29,19 @@ class FeatureFlags(BaseModel, ABC):
     def mark_overridden_features(cls, values):
         assert isinstance(values, dict)
         values["overriden_features"] = values.copy()
+        cls._validate_overridden_features(values)
         return values
 
+    @classmethod
+    def _validate_overridden_features(cls, values: dict):
+        """Validates overridden features to ensure they are defined in the model fields."""
+        defined_fields = cls.model_fields.keys()
+        invalid_features = [key for key in values.keys() if key not in defined_fields]
+
+        if invalid_features:
+            message = f"Invalid feature toggle(s) supplied: {invalid_features}. "
+            raise ValueError(message)
+
     def _get_flags(self):
         flags = type(self).get_config_server().best_effort_get_all_feature_flags()
         return {f: flags[f] for f in flags if f in self.model_fields.keys()}

mx_bluesky/{hyperion → common}/external_interaction/ispyb/data_model.py

@@ -70,6 +70,8 @@ class DataCollectionPositionInfo:
 
 @dataclass
 class DataCollectionGridInfo:
+    """This information is used by Zocalo gridscan per-image-analysis"""
+
     dx_in_mm: float
     dy_in_mm: float
     steps_x: int

mx_bluesky/{hyperion → common}/external_interaction/ispyb/exp_eye_store.py

@@ -5,11 +5,11 @@ from enum import StrEnum
 from requests import patch, post
 from requests.auth import AuthBase
 
-from mx_bluesky.hyperion.external_interaction.exceptions import ISPyBDepositionNotMade
-from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_utils import (
+from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import (
     get_current_time_string,
     get_ispyb_config,
 )
+from mx_bluesky.common.utils.exceptions import ISPyBDepositionNotMade
 
 RobotActionID = int
 
@@ -54,9 +54,9 @@ class BLSampleStatus(StrEnum):
     ERROR_BEAMLINE = "ERROR - beamline"
 
 
-assert all(
-    len(value) <= 20 for value in BLSampleStatus
-), "Column size limit of 20 for BLSampleStatus"
+assert all(len(value) <= 20 for value in BLSampleStatus), (
+    "Column size limit of 20 for BLSampleStatus"
+)
 
 
 class ExpeyeInteraction: