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

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

@@ -10,20 +10,7 @@ schematics corresponds to soft_in_2 in the code.
 """
 
 import bluesky.plan_stubs as bps
-from dodal.devices.zebra import (
-    AND3,
-    AND4,
-    DISCONNECT,
-    IN1_TTL,
-    IN3_TTL,
-    OR1,
-    PC_ARM,
-    PC_GATE,
-    PC_PULSE,
-    PULSE1,
-    PULSE2,
-    SOFT_IN2,
-    SOFT_IN3,
+from dodal.devices.zebra.zebra import (
     ArmDemand,
     ArmSource,
     I24Axes,
@@ -131,7 +118,9 @@ def setup_zebra_for_quickshot_plan(
     yield from bps.abs_set(zebra.pc.gate_start, GATE_START, group=group)
     yield from bps.abs_set(zebra.pc.gate_width, gate_width, group=group)
 
-    yield from bps.abs_set(zebra.pc.gate_input, SOFT_IN2, group=group)
+    yield from bps.abs_set(
+        zebra.pc.gate_input, zebra.mapping.sources.SOFT_IN2, group=group
+    )
     yield from bps.sleep(0.1)
 
     if wait:
@@ -144,17 +133,25 @@ def set_logic_gates_for_porto_triggering(
 ):
     # To OUT2_TTL
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[3].sources[1], SOFT_IN2, group=group
+        zebra.logic_gates.and_gates[3].sources[1],
+        zebra.mapping.sources.SOFT_IN2,
+        group=group,
     )
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[3].sources[2], PULSE1, group=group
+        zebra.logic_gates.and_gates[3].sources[2],
+        zebra.mapping.sources.PULSE1,
+        group=group,
     )
     # To OUT1_TTL
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[4].sources[1], SOFT_IN2, group=group
+        zebra.logic_gates.and_gates[4].sources[1],
+        zebra.mapping.sources.SOFT_IN2,
+        group=group,
     )
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[4].sources[2], PULSE2, group=group
+        zebra.logic_gates.and_gates[4].sources[2],
+        zebra.mapping.sources.PULSE2,
+        group=group,
     )
     yield from bps.wait(group=group)
 
@@ -215,10 +212,16 @@ def setup_zebra_for_extruder_with_pump_probe_plan(
     # Set TTL out depending on detector type
     DET_TTL = TTL_EIGER if det_type == "eiger" else TTL_PILATUS
     LASER_TTL = TTL_PILATUS if det_type == "eiger" else TTL_EIGER
-    yield from bps.abs_set(zebra.output.out_pvs[DET_TTL], AND4, group=group)
-    yield from bps.abs_set(zebra.output.out_pvs[LASER_TTL], AND3, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[DET_TTL], zebra.mapping.sources.AND4, group=group
+    )
+    yield from bps.abs_set(
+        zebra.output.out_pvs[LASER_TTL], zebra.mapping.sources.AND3, group=group
+    )
 
-    yield from bps.abs_set(zebra.pc.gate_input, SOFT_IN2, group=group)
+    yield from bps.abs_set(
+        zebra.pc.gate_input, zebra.mapping.sources.SOFT_IN2, group=group
+    )
 
     assert pump_exp and pump_delay, "Must supply pump_exp and pump_delay!"
     gate_width, gate_step = get_zebra_settings_for_extruder(
@@ -242,7 +245,9 @@ def setup_zebra_for_extruder_with_pump_probe_plan(
     SSX_LOGGER.info(
         f"Pulse1 starting at {pulse1_delay} with width set to laser dwell {pump_exp}."
     )
-    yield from bps.abs_set(zebra.output.pulse_1.input, PC_GATE, group=group)
+    yield from bps.abs_set(
+        zebra.output.pulse_1.input, zebra.mapping.sources.PC_GATE, group=group
+    )
     yield from bps.abs_set(zebra.output.pulse_1.delay, pulse1_delay, group=group)
     yield from bps.abs_set(zebra.output.pulse_1.width, pump_exp, group=group)
     SSX_LOGGER.info(
@@ -251,7 +256,9 @@ def setup_zebra_for_extruder_with_pump_probe_plan(
         exposure time {exp_time}.
         """
     )
-    yield from bps.abs_set(zebra.output.pulse_2.input, PC_GATE, group=group)
+    yield from bps.abs_set(
+        zebra.output.pulse_2.input, zebra.mapping.sources.PC_GATE, group=group
+    )
     yield from bps.abs_set(zebra.output.pulse_2.delay, pump_delay, group=group)
     yield from bps.abs_set(zebra.output.pulse_2.width, exp_time, group=group)
 
@@ -308,20 +315,30 @@ def setup_zebra_for_fastchip_plan(
 
     # Logic Gates
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[3].sources[1], SOFT_IN2, group=group
+        zebra.logic_gates.and_gates[3].sources[1],
+        zebra.mapping.sources.SOFT_IN2,
+        group=group,
     )
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[3].sources[2], PC_PULSE, group=group
+        zebra.logic_gates.and_gates[3].sources[2],
+        zebra.mapping.sources.PC_PULSE,
+        group=group,
     )
 
-    yield from bps.abs_set(zebra.pc.gate_input, IN3_TTL, group=group)
+    yield from bps.abs_set(
+        zebra.pc.gate_input, zebra.mapping.sources.IN3_TTL, group=group
+    )
 
     # Set TTL out depending on detector type
     # And calculate some of the other settings
     if det_type == "eiger":
-        yield from bps.abs_set(zebra.output.out_pvs[TTL_EIGER], AND3, group=group)
+        yield from bps.abs_set(
+            zebra.output.out_pvs[TTL_EIGER], zebra.mapping.sources.AND3, group=group
+        )
     if det_type == "pilatus":
-        yield from bps.abs_set(zebra.output.out_pvs[TTL_PILATUS], AND3, group=group)
+        yield from bps.abs_set(
+            zebra.output.out_pvs[TTL_PILATUS], zebra.mapping.sources.AND3, group=group
+        )
 
     # 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
@@ -374,13 +391,19 @@ def open_fast_shutter_at_each_position_plan(
     )
     SSX_LOGGER.debug("Controlling the fast shutter on PULSE2.")
     # Output panel pulse_2 settings
-    yield from bps.abs_set(zebra.output.pulse_2.input, PC_GATE, group=group)
+    yield from bps.abs_set(
+        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
     yield from bps.abs_set(zebra.output.pulse_2.width, pulse2_width, group=group)
 
     # Fast shutter
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_FAST_SHUTTER], PULSE2, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[TTL_FAST_SHUTTER],
+        zebra.mapping.sources.PULSE2,
+        group=group,
+    )
 
     if wait:
         yield from bps.wait(group=group)
@@ -396,12 +419,22 @@ def reset_pc_gate_and_pulse(zebra: Zebra, group: str = "reset_pc"):
 
 def reset_output_panel(zebra: Zebra, group: str = "reset_zebra_outputs"):
     # Reset TTL out
-    yield from bps.abs_set(zebra.output.out_pvs[2], PC_GATE, group=group)
-    yield from bps.abs_set(zebra.output.out_pvs[3], DISCONNECT, group=group)
-    yield from bps.abs_set(zebra.output.out_pvs[4], OR1, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[2], zebra.mapping.sources.PC_GATE, group=group
+    )
+    yield from bps.abs_set(
+        zebra.output.out_pvs[3], zebra.mapping.sources.DISCONNECT, group=group
+    )
+    yield from bps.abs_set(
+        zebra.output.out_pvs[4], zebra.mapping.sources.OR1, group=group
+    )
 
-    yield from bps.abs_set(zebra.output.pulse_1.input, DISCONNECT, group=group)
-    yield from bps.abs_set(zebra.output.pulse_2.input, DISCONNECT, group=group)
+    yield from bps.abs_set(
+        zebra.output.pulse_1.input, zebra.mapping.sources.DISCONNECT, group=group
+    )
+    yield from bps.abs_set(
+        zebra.output.pulse_2.input, zebra.mapping.sources.DISCONNECT, group=group
+    )
 
     yield from bps.wait(group=group)
 
@@ -418,16 +451,24 @@ def zebra_return_to_normal_plan(
     # Reset PC_GATE and PC_SOURCE to "Position"
     yield from setup_pc_sources(zebra, TrigSource.POSITION, TrigSource.POSITION)
 
-    yield from bps.abs_set(zebra.pc.gate_input, SOFT_IN3, group=group)
+    yield from bps.abs_set(
+        zebra.pc.gate_input, zebra.mapping.sources.SOFT_IN3, group=group
+    )
     yield from bps.abs_set(zebra.pc.num_gates, 1, group=group)
-    yield from bps.abs_set(zebra.pc.pulse_input, DISCONNECT, group=group)
+    yield from bps.abs_set(
+        zebra.pc.pulse_input, zebra.mapping.sources.DISCONNECT, group=group
+    )
 
     # Logic Gates
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[3].sources[1], PC_ARM, group=group
+        zebra.logic_gates.and_gates[3].sources[1],
+        zebra.mapping.sources.PC_ARM,
+        group=group,
     )
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[3].sources[2], IN1_TTL, group=group
+        zebra.logic_gates.and_gates[3].sources[2],
+        zebra.mapping.sources.IN1_TTL,
+        group=group,
     )
 
     # Reset TTL out

mx_bluesky/beamlines/i24/serial/write_nexus.py

@@ -3,7 +3,6 @@ import pathlib
 import pprint
 import time
 from datetime import datetime
-from typing import Literal
 
 import requests
 
@@ -13,43 +12,49 @@ from mx_bluesky.beamlines.i24.serial.parameters import (
     ExtruderParameters,
     FixedTargetParameters,
 )
-from mx_bluesky.beamlines.i24.serial.setup_beamline import Eiger, caget, cagetstring
+from mx_bluesky.beamlines.i24.serial.setup_beamline import Eiger, caget
 
 
 def call_nexgen(
     chip_prog_dict: dict | None,
-    start_time: datetime,
     parameters: ExtruderParameters | FixedTargetParameters,
-    wavelength: float,
-    expt_type: Literal["fixed-target", "extruder"] = "fixed-target",
+    wavelength_in_a: float,
+    beam_center_in_pix: tuple[float, float],
+    start_time: datetime | None = None,
 ):
-    det_type = parameters.detector_name
-    print(f"det_type: {det_type}")
+    """Call the nexus writer by sending a request to nexgen-server.
 
+    Args:
+        chip_prog_dict (dict | None): Dictionary containing most of the information \
+            passed to the program runner for the collection. Only used for fixed target.
+        start_time
+        parameters (SerialAndLaserExperiment): Collection parameters.
+        wavelength_in_a (float): Wavelength, in A.
+        beam_center_in_pix (list[float]): Beam center position on detector, in pixels.
+        start_time (datetime, optional): Collection start time.
+
+    Raises:
+        ValueError: For a wrong experiment type passed (either unknwon or not matched \
+            to parameter model).
+
+    """
     current_chip_map = None
-    if expt_type == "fixed-target" and isinstance(parameters, FixedTargetParameters):
-        if not (
-            parameters.map_type == MappingType.NoMap
-            or parameters.chip.chip_type == ChipType.Custom
-        ):
-            # NOTE Nexgen server is still on nexgen v0.7.2 (fully working for ssx)
-            # Will need to be updated, for correctness sake map needs to be None.
-            current_chip_map = "/dls_sw/i24/scripts/fastchips/litemaps/currentchip.map"
-        pump_status = bool(parameters.pump_repeat)
-        total_numb_imgs = parameters.total_num_images
-    elif expt_type == "extruder" and isinstance(parameters, ExtruderParameters):
-        # chip_prog_dict should be None for extruder (passed as input for now)
-        total_numb_imgs = parameters.num_images
-        pump_status = parameters.pump_status
-    else:
-        raise ValueError(f"{expt_type=} not recognised")
+    match parameters:
+        case FixedTargetParameters():
+            if not (
+                parameters.map_type == MappingType.NoMap
+                or parameters.chip.chip_type == ChipType.Custom
+            ):
+                # For nexgen >= 0.9.10
+                current_chip_map = parameters.chip_map
+            pump_status = bool(parameters.pump_repeat)
+            total_numb_imgs = parameters.total_num_images
+        case ExtruderParameters():
+            total_numb_imgs = parameters.num_images
+            pump_status = parameters.pump_status
 
-    filename_prefix = cagetstring(Eiger.pv.filenameRBV)
-    meta_h5 = (
-        pathlib.Path(parameters.visit)
-        / parameters.directory
-        / f"{filename_prefix}_meta.h5"
-    )
+    filename_prefix = parameters.filename
+    meta_h5 = parameters.visit / parameters.directory / f"{filename_prefix}_meta.h5"
     t0 = time.time()
     max_wait = 60  # seconds
     SSX_LOGGER.info(f"Watching for {meta_h5}")
@@ -62,44 +67,38 @@ def call_nexgen(
         time.sleep(1)
     if not meta_h5.exists():
         SSX_LOGGER.warning(f"Giving up waiting for {meta_h5} after {max_wait} seconds")
-        return False
+        return
 
-    transmission = (float(caget(Eiger.pv.transmission)),)
-
-    if det_type == Eiger.name:
-        bit_depth = int(caget(Eiger.pv.bit_depth))
-        SSX_LOGGER.debug(
-            f"Call to nexgen server with the following chip definition: \n{chip_prog_dict}"
-        )
+    bit_depth = int(caget(Eiger.pv.bit_depth))
+    SSX_LOGGER.debug(
+        f"Call to nexgen server with the following chip definition: \n{chip_prog_dict}"
+    )
 
-        access_token = pathlib.Path("/scratch/ssx_nexgen.key").read_text().strip()
-        url = "https://ssx-nexgen.diamond.ac.uk/ssx_eiger/write"
-        headers = {"Authorization": f"Bearer {access_token}"}
+    access_token = pathlib.Path("/scratch/ssx_nexgen.key").read_text().strip()
+    url = "https://ssx-nexgen.diamond.ac.uk/ssx_eiger/write"
+    headers = {"Authorization": f"Bearer {access_token}"}
 
-        payload = {
-            "beamline": "i24",
-            "beam_center": [caget(Eiger.pv.beamx), caget(Eiger.pv.beamy)],
-            "chipmap": current_chip_map,
-            "chip_info": chip_prog_dict,
-            "det_dist": parameters.detector_distance_mm,
-            "exp_time": parameters.exposure_time_s,
-            "expt_type": expt_type,
-            "filename": filename_prefix,
-            "num_imgs": total_numb_imgs,
-            "pump_status": pump_status,
-            "pump_exp": parameters.laser_dwell_s,
-            "pump_delay": parameters.laser_delay_s,
-            "transmission": transmission[0],
-            "visitpath": os.fspath(meta_h5.parent),
-            "wavelength": wavelength,
-            "bit_depth": bit_depth,
-        }
-        SSX_LOGGER.info(f"Sending POST request to {url} with payload:")
-        SSX_LOGGER.info(pprint.pformat(payload))
-        response = requests.post(url, headers=headers, json=payload)
-        SSX_LOGGER.info(
-            f"Response: {response.text} (status code: {response.status_code})"
-        )
-        # the following will raise an error if the request was unsuccessful
-        return response.status_code == requests.codes.ok
-    return False
+    payload = {
+        "beamline": "i24",
+        "beam_center": beam_center_in_pix,
+        "chipmap": current_chip_map,
+        "chip_info": chip_prog_dict,
+        "det_dist": parameters.detector_distance_mm,
+        "exp_time": parameters.exposure_time_s,
+        "expt_type": parameters.nexgen_experiment_type,
+        "filename": filename_prefix,
+        "num_imgs": total_numb_imgs,
+        "pump_status": pump_status,
+        "pump_exp": parameters.laser_dwell_s,
+        "pump_delay": parameters.laser_delay_s,
+        "transmission": parameters.transmission,
+        "visitpath": os.fspath(meta_h5.parent),
+        "wavelength": wavelength_in_a,
+        "bit_depth": bit_depth,
+        "start_time": start_time,
+    }
+    SSX_LOGGER.info(f"Sending POST request to {url} with payload:")
+    SSX_LOGGER.info(pprint.pformat(payload))
+    response = requests.post(url, headers=headers, json=payload)
+    response.raise_for_status()
+    SSX_LOGGER.info(f"Response: {response.text} (status code: {response.status_code})")

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

@@ -1,7 +1,7 @@
 from bluesky.callbacks import CallbackBase
 from event_model.documents.run_start import RunStart
 
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 
 from .logging_callback import format_doc_for_log
 

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

@@ -5,10 +5,28 @@ from bluesky.callbacks import CallbackBase
 from dodal.devices.oav.utils import calculate_x_y_z_of_pixel
 from event_model.documents import Event
 
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 
 
 class GridParamUpdate(TypedDict):
+    """
+    Grid parameters extracted from the grid detection.
+    Positions are in motor-space.
+
+    Attributes:
+        x_start_um: x position of the centre of the first xy-gridscan box in microns
+        y_start_um: y position of the centre of the first xy-gridscan box in microns
+        y2_start_um: y position of the centre of the first xz-gridscan box in microns
+        z_start_um: z position of the centre of the first xy-gridscan box in microns
+        z2_start_um: z position of the centre of the first xz-gridscan box in microns
+        x_steps: Number of grid boxes in x-direction for xy- and xz- gridscans
+        y_steps: Number of grid boxes in y-direction for xy-gridscan
+        z_steps: Number of grid boxes in z-direction for xz-gridscan
+        x_step_size_um: x-dimension of the grid box
+        y_step_size_um: y-dimension of the grid box
+        z_step_size_um: z-dimension of the grid box
+    """
+
     x_start_um: float
     y_start_um: float
     y2_start_um: float

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):