mx-bluesky 1.4.1a0__py3-none-any.whl → 1.4.3__py3-none-any.whl

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

@@ -5,10 +5,13 @@ 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,
+    TriggerConstants,
+)
+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
@@ -39,11 +42,13 @@ class ZocaloCallback(CallbackBase):
         self._reset_state()
 
     def start(self, doc: RunStart):
-        ISPYB_LOGGER.info("Zocalo handler received start document.")
-        if triggering_plan := doc.get(CONST.TRIGGER.ZOCALO):
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info("Zocalo handler received start document.")
+        if triggering_plan := doc.get(TriggerConstants.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}.")
+            ISPYB_ZOCALO_CALLBACK_LOGGER.info(
+                f"Zocalo environment set to {zocalo_environment}."
+            )
             self.zocalo_interactor = ZocaloTrigger(zocalo_environment)
 
         if self.triggering_plan and doc.get("subplan_name") == self.triggering_plan:
@@ -73,7 +78,7 @@ 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
@@ -83,7 +88,7 @@ class ZocaloCallback(CallbackBase):
 
     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,57 +12,61 @@ 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
 
 
 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": PlanNameConstants.GRID_DETECT_AND_DO_GRIDSCAN,
+                "mx_bluesky_parameters": parameters.model_dump_json(),
+            },
+        ),
+        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
@@ -80,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)
 
@@ -137,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
@@ -151,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)}"
         )
 
@@ -173,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
         )
@@ -222,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]
 
@@ -242,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],
@@ -267,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

@@ -1,13 +1,15 @@
 import configparser
+from dataclasses import dataclass
+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
 
@@ -29,20 +31,44 @@ def _get_base_url_and_token() -> tuple[str, str]:
     return expeye_config["url"], expeye_config["token"]
 
 
+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}")
+    return response.json()
+
+
+@dataclass
+class BLSample:
+    container_id: int
+    bl_sample_id: int
+    bl_sample_status: str | None
+
+
+class BLSampleStatus(StrEnum):
+    # The sample has been loaded
+    LOADED = "LOADED"
+    # Problem with the sample e.g. pin too long/short
+    ERROR_SAMPLE = "ERROR - sample"
+    # Any other general error
+    ERROR_BEAMLINE = "ERROR - beamline"
+
+
+assert all(len(value) <= 20 for value in BLSampleStatus), (
+    "Column size limit of 20 for BLSampleStatus"
+)
+
+
 class ExpeyeInteraction:
+    """Exposes functionality from the Expeye core API"""
+
     CREATE_ROBOT_ACTION = "/proposals/{proposal}/sessions/{visit_number}/robot-actions"
     UPDATE_ROBOT_ACTION = "/robot-actions/{action_id}"
 
     def __init__(self) -> None:
         url, token = _get_base_url_and_token()
-        self.base_url = url
-        self.auth = BearerAuth(token)
-
-    def _send_and_get_response(self, url, data, send_func) -> dict:
-        response = send_func(url, auth=self.auth, json=data)
-        if not response.ok:
-            raise ISPyBDepositionNotMade(f"Could not write {data} to {url}: {response}")
-        return response.json()
+        self._base_url = url
+        self._auth = BearerAuth(token)
 
     def start_load(
         self,
@@ -66,7 +92,7 @@ class ExpeyeInteraction:
         Returns:
             RobotActionID: The id of the robot load action that is created
         """
-        url = self.base_url + self.CREATE_ROBOT_ACTION.format(
+        url = self._base_url + self.CREATE_ROBOT_ACTION.format(
             proposal=proposal_reference, visit_number=visit_number
         )
 
@@ -77,7 +103,7 @@ class ExpeyeInteraction:
             "containerLocation": container_location,
             "dewarLocation": dewar_location,
         }
-        response = self._send_and_get_response(url, data, post)
+        response = _send_and_get_response(self._auth, url, data, post)
         return response["robotActionId"]
 
     def update_barcode_and_snapshots(
@@ -95,14 +121,14 @@ class ExpeyeInteraction:
             snapshot_before_path (str): Path to the snapshot before robot load
             snapshot_after_path (str): Path to the snapshot after robot load
         """
-        url = self.base_url + self.UPDATE_ROBOT_ACTION.format(action_id=action_id)
+        url = self._base_url + self.UPDATE_ROBOT_ACTION.format(action_id=action_id)
 
         data = {
             "sampleBarcode": barcode,
             "xtalSnapshotBefore": snapshot_before_path,
             "xtalSnapshotAfter": snapshot_after_path,
         }
-        self._send_and_get_response(url, data, patch)
+        _send_and_get_response(self._auth, url, data, patch)
 
     def end_load(self, action_id: RobotActionID, status: str, reason: str):
         """Finish an existing robot action, providing final information about how it went
@@ -113,13 +139,37 @@ class ExpeyeInteraction:
                           otherwise error
             reason (str): If the status is in error than the reason for that error
         """
-        url = self.base_url + self.UPDATE_ROBOT_ACTION.format(action_id=action_id)
+        url = self._base_url + self.UPDATE_ROBOT_ACTION.format(action_id=action_id)
 
         run_status = "SUCCESS" if status == "success" else "ERROR"
 
         data = {
             "endTimestamp": get_current_time_string(),
             "status": run_status,
-            "message": reason,
+            "message": reason[:255] if reason else "",
         }
-        self._send_and_get_response(url, data, patch)
+        _send_and_get_response(self._auth, url, data, patch)
+
+    def update_sample_status(
+        self, bl_sample_id: int, bl_sample_status: BLSampleStatus
+    ) -> BLSample:
+        """Update the blSampleStatus of a sample.
+        Args:
+            bl_sample_id: The sample ID
+            bl_sample_status: The sample status
+            status_message: An optional message
+        Returns:
+             The updated sample
+        """
+        data = {"blSampleStatus": (str(bl_sample_status))}
+        response = _send_and_get_response(
+            self._auth, self._base_url + f"/samples/{bl_sample_id}", data, patch
+        )
+        return self._sample_from_json(response)
+
+    def _sample_from_json(self, response) -> BLSample:
+        return BLSample(
+            bl_sample_id=response["blSampleId"],
+            bl_sample_status=response["blSampleStatus"],
+            container_id=response["containerId"],
+        )

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

@@ -11,18 +11,18 @@ from ispyb.sp.mxacquisition import MXAcquisition
 from ispyb.strictordereddict import StrictOrderedDict
 from pydantic import BaseModel
 
-from mx_bluesky.common.utils.tracing import TRACER
-from mx_bluesky.hyperion.external_interaction.ispyb.data_model import (
+from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionGridInfo,
     DataCollectionGroupInfo,
     DataCollectionInfo,
     ScanDataInfo,
 )
-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_session_id_from_visit,
 )
-from mx_bluesky.hyperion.log import ISPYB_LOGGER
+from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER
+from mx_bluesky.common.utils.tracing import TRACER
 
 if TYPE_CHECKING:
     pass
@@ -62,12 +62,12 @@ class StoreInIspyb:
         ispyb_ids,
         scan_data_infos: Sequence[ScanDataInfo],
     ) -> IspybIds:
-        assert (
-            ispyb_ids.data_collection_group_id
-        ), "Attempted to store scan data without a collection group"
-        assert (
-            ispyb_ids.data_collection_ids
-        ), "Attempted to store scan data without a collection"
+        assert ispyb_ids.data_collection_group_id, (
+            "Attempted to store scan data without a collection group"
+        )
+        assert ispyb_ids.data_collection_ids, (
+            "Attempted to store scan data without a collection"
+        )
         return self._begin_or_update_deposition(ispyb_ids, None, scan_data_infos)
 
     def _begin_or_update_deposition(
@@ -87,7 +87,9 @@ class StoreInIspyb:
                     )
                 )
             else:
-                assert ispyb_ids.data_collection_group_id, "Attempt to update data collection without a data collection group ID"
+                assert ispyb_ids.data_collection_group_id, (
+                    "Attempt to update data collection without a data collection group ID"
+                )
 
             grid_ids = list(ispyb_ids.grid_ids)
             data_collection_ids_out = list(ispyb_ids.data_collection_ids)
@@ -116,15 +118,15 @@ class StoreInIspyb:
         return ispyb_ids
 
     def end_deposition(self, ispyb_ids: IspybIds, success: str, reason: str):
-        assert (
-            ispyb_ids.data_collection_ids
-        ), "Can't end ISPyB deposition, data_collection IDs are missing"
-        assert (
-            ispyb_ids.data_collection_group_id is not None
-        ), "Cannot end ISPyB deposition without data collection group ID"
+        assert ispyb_ids.data_collection_ids, (
+            "Can't end ISPyB deposition, data_collection IDs are missing"
+        )
+        assert ispyb_ids.data_collection_group_id is not None, (
+            "Cannot end ISPyB deposition without data collection group ID"
+        )
 
         for id_ in ispyb_ids.data_collection_ids:
-            ISPYB_LOGGER.info(
+            ISPYB_ZOCALO_CALLBACK_LOGGER.info(
                 f"End ispyb deposition with status '{success}' and reason '{reason}'."
             )
             if success == "fail" or success == "abort":

mx_bluesky/{hyperion → 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.hyperion.parameters.constants import CONST
+from mx_bluesky.common.parameters.constants import SimConstants
 
 
 def get_ispyb_config():
-    return os.environ.get("ISPYB_CONFIG_PATH", CONST.SIM.ISPYB_CONFIG)
+    return os.environ.get("ISPYB_CONFIG_PATH", SimConstants.ISPYB_CONFIG)
 
 
 def get_session_id_from_visit(conn: Connector, visit: str):