mx-bluesky 1.5.11__py3-none-any.whl → 1.5.14__py3-none-any.whl

mx_bluesky/common/external_interaction/ispyb/exp_eye_store.py

@@ -7,6 +7,12 @@ from event_model.documents import Event
 from requests import JSONDecodeError, patch, post
 from requests.auth import AuthBase
 
+from mx_bluesky.common.external_interaction.ispyb.data_model import (
+    DataCollectionGridInfo,
+    DataCollectionGroupInfo,
+    DataCollectionInfo,
+    DataCollectionPositionInfo,
+)
 from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import (
     get_current_time_string,
     get_ispyb_config,
@@ -33,8 +39,8 @@ 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)
+def _send_and_get_response(auth, url, data, send_func, query_params=None) -> dict:
+    response = send_func(url, auth=auth, json=data, params=query_params)
     if not response.ok:
         try:
             resp_txt = str(response.json())
@@ -181,3 +187,154 @@ class ExpeyeInteraction:
             bl_sample_status=response["blSampleStatus"],
             container_id=response["containerId"],
         )
+
+    def create_data_group(
+        self, proposal_reference: str, visit_number: int, data: DataCollectionGroupInfo
+    ) -> int:
+        response = _send_and_get_response(
+            self._auth,
+            self._base_url + f"/proposals/{proposal_reference}/sessions/"
+            f"{visit_number}/data-groups",
+            _data_collection_group_info_to_json(data),
+            post,
+        )
+        return response["dataCollectionGroupId"]
+
+    def update_data_group(self, group_id: int, data: DataCollectionGroupInfo):
+        _send_and_get_response(
+            self._auth,
+            self._base_url + f"/data-groups/{group_id}",
+            _data_collection_group_info_to_json(data),
+            patch,
+        )
+
+    def create_data_collection(self, group_id: int, data: DataCollectionInfo) -> int:
+        response = _send_and_get_response(
+            self._auth,
+            self._base_url + f"/data-groups/{group_id}/data-collections",
+            _data_collection_info_to_json(data),
+            post,
+        )
+        return response["dataCollectionId"]
+
+    def update_data_collection(
+        self,
+        data_collection_id: int,
+        data: DataCollectionInfo,
+        append_comment: bool = False,
+    ):
+        _send_and_get_response(
+            self._auth,
+            self._base_url + f"/data-collections/{data_collection_id}",
+            _data_collection_info_to_json(data),
+            patch,
+            {"appendComment": "true"} if append_comment else None,
+        )
+
+    def create_position(
+        self, data_collection_id: int, data: DataCollectionPositionInfo
+    ):
+        _send_and_get_response(
+            self._auth,
+            self._base_url + f"/data-collections/{data_collection_id}/position",
+            _position_info_to_json(data),
+            post,
+        )
+
+    def create_grid(self, data_collection_id: int, data: DataCollectionGridInfo) -> int:
+        response = _send_and_get_response(
+            self._auth,
+            self._base_url + f"/data-collections/{data_collection_id}/grids",
+            _grid_info_to_json(data),
+            post,
+        )
+        return response["gridInfoId"]
+
+
+def _none_to_absent(json: dict) -> dict:
+    for key in [key for key in json if json[key] is None]:
+        del json[key]
+    return json
+
+
+def _data_collection_group_info_to_json(data: DataCollectionGroupInfo) -> dict:
+    return _none_to_absent(
+        {
+            "experimentType": data.experiment_type,
+            "sampleId": data.sample_id,
+            "actualSampleBarcode": data.sample_barcode,
+            "comments": data.comments,
+        }
+    )
+
+
+def _data_collection_info_to_json(data: DataCollectionInfo) -> dict:
+    return _none_to_absent(
+        {
+            "omegaStart": data.omega_start,
+            "dataCollectionNumber": data.data_collection_number,
+            "xtalSnapshotFullPath1": data.xtal_snapshot1,
+            "xtalSnapshotFullPath2": data.xtal_snapshot2,
+            "xtalSnapshotFullPath3": data.xtal_snapshot3,
+            "xtalSnapshotFullPath4": data.xtal_snapshot4,
+            "numberOfImages": data.n_images,
+            "axisRange": data.axis_range,
+            "axisEnd": data.axis_end,
+            "chiStart": data.chi_start,
+            "kappaStart": data.kappa_start,
+            "detectorId": data.detector_id,
+            "axisStart": data.axis_start,
+            "slitGapVertical": data.slitgap_vertical,
+            "slitGapHorizontal": data.slitgap_horizontal,
+            "beamSizeAtSampleX": data.beamsize_at_samplex,
+            "beamSizeAtSampleY": data.beamsize_at_sampley,
+            "transmission": data.transmission,
+            "comments": data.comments,
+            "detectorDistance": data.detector_distance,
+            "exposureTime": data.exp_time,
+            "imageDirectory": data.imgdir,
+            "fileTemplate": data.file_template,
+            "imagePrefix": data.imgprefix,
+            "imageSuffix": data.imgsuffix,
+            "numberOfPasses": data.n_passes,
+            "overlap": data.overlap,
+            "flux": data.flux,
+            "startImageNumber": data.start_image_number,
+            "resolution": data.resolution,
+            "wavelength": data.wavelength,
+            "xBeam": data.xbeam,
+            "yBeam": data.ybeam,
+            "synchrotronMode": data.synchrotron_mode,
+            "undulatorGap1": data.undulator_gap1,
+            "startTime": data.start_time,
+            "endTime": data.end_time,
+            "runStatus": data.run_status,
+        }
+    )
+
+
+def _position_info_to_json(data: DataCollectionPositionInfo) -> dict:
+    return _none_to_absent(
+        {
+            "posX": data.pos_x,
+            "posY": data.pos_y,
+            "posZ": data.pos_z,
+        }
+    )
+
+
+def _grid_info_to_json(data: DataCollectionGridInfo) -> dict:
+    return _none_to_absent(
+        {
+            "snapshotOffsetXPixel": data.snapshot_offset_x_pixel,
+            "snapshotOffsetYPixel": data.snapshot_offset_y_pixel,
+            "dx": data.dx_in_mm,
+            "dy": data.dy_in_mm,
+            "stepsX": data.steps_x,
+            "stepsY": data.steps_y,
+            "orientation": data.orientation.value,
+            "micronsPerPixelX": data.microns_per_pixel_x,
+            "micronsPerPixelY": data.microns_per_pixel_y,
+            "snaked": data.snaked,
+        }
+    )

mx_bluesky/common/external_interaction/ispyb/ispyb_store.py

@@ -1,35 +1,28 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from dataclasses import asdict
 from typing import TYPE_CHECKING
 
-import ispyb
-import numpy as np
-from ispyb.connector.mysqlsp.main import ISPyBMySQLSPConnector as Connector
-from ispyb.sp.mxacquisition import MXAcquisition
-from ispyb.strictordereddict import StrictOrderedDict
 from pydantic import BaseModel
 
+from mx_bluesky.common.external_interaction.callbacks.common.ispyb_mapping import (
+    get_proposal_and_session_from_visit_string,
+)
 from mx_bluesky.common.external_interaction.ispyb.data_model import (
-    DataCollectionGridInfo,
     DataCollectionGroupInfo,
     DataCollectionInfo,
     ScanDataInfo,
 )
+from mx_bluesky.common.external_interaction.ispyb.exp_eye_store import ExpeyeInteraction
 from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import (
     get_current_time_string,
-    get_session_id_from_visit,
 )
+from mx_bluesky.common.utils.exceptions import ISPyBDepositionNotMadeError
 from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER
-from mx_bluesky.common.utils.tracing import TRACER
 
 if TYPE_CHECKING:
     pass
 
-I03_EIGER_DETECTOR = 78
-EIGER_FILE_SUFFIX = "h5"
-
 
 class IspybIds(BaseModel):
     data_collection_ids: tuple[int, ...] = ()
@@ -40,6 +33,7 @@ class IspybIds(BaseModel):
 class StoreInIspyb:
     def __init__(self, ispyb_config: str) -> None:
         self.ISPYB_CONFIG_PATH: str = ispyb_config
+        self._expeye = ExpeyeInteraction()
 
     def begin_deposition(
         self,
@@ -75,45 +69,41 @@ class StoreInIspyb:
         data_collection_group_info: DataCollectionGroupInfo | None,
         scan_data_infos,
     ) -> IspybIds:
-        with ispyb.open(self.ISPYB_CONFIG_PATH) as conn:
-            assert conn, "Failed to connect to ISPyB"
-            if data_collection_group_info:
-                ispyb_ids.data_collection_group_id = (
-                    self._store_data_collection_group_table(
-                        conn,
-                        data_collection_group_info,
-                        ispyb_ids.data_collection_group_id,
-                    )
-                )
-            else:
-                assert ispyb_ids.data_collection_group_id, (
-                    "Attempt to update data collection without a data collection group ID"
+        if data_collection_group_info:
+            ispyb_ids.data_collection_group_id = (
+                self._store_data_collection_group_table(
+                    data_collection_group_info, ispyb_ids.data_collection_group_id
                 )
+            )
+        else:
+            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)
-            for scan_data_info in scan_data_infos:
-                data_collection_id = scan_data_info.data_collection_id
-                if (
-                    scan_data_info.data_collection_info
-                    and not scan_data_info.data_collection_info.parent_id
-                ):
-                    scan_data_info.data_collection_info.parent_id = (
-                        ispyb_ids.data_collection_group_id
-                    )
-
-                new_data_collection_id, grid_id = self._store_single_scan_data(
-                    conn, scan_data_info, data_collection_id
+        grid_ids = list(ispyb_ids.grid_ids)
+        data_collection_ids_out = list(ispyb_ids.data_collection_ids)
+        for scan_data_info in scan_data_infos:
+            data_collection_id = scan_data_info.data_collection_id
+            if (
+                scan_data_info.data_collection_info
+                and not scan_data_info.data_collection_info.parent_id
+            ):
+                scan_data_info.data_collection_info.parent_id = (
+                    ispyb_ids.data_collection_group_id
                 )
-                if not data_collection_id:
-                    data_collection_ids_out.append(new_data_collection_id)
-                if grid_id:
-                    grid_ids.append(grid_id)
-            ispyb_ids = IspybIds(
-                data_collection_ids=tuple(data_collection_ids_out),
-                grid_ids=tuple(grid_ids),
-                data_collection_group_id=ispyb_ids.data_collection_group_id,
+
+            new_data_collection_id, grid_id = self._store_single_scan_data(
+                scan_data_info, data_collection_id
             )
+            if not data_collection_id:
+                data_collection_ids_out.append(new_data_collection_id)
+            if grid_id:
+                grid_ids.append(grid_id)
+        ispyb_ids = IspybIds(
+            data_collection_ids=tuple(data_collection_ids_out),
+            grid_ids=tuple(grid_ids),
+            data_collection_group_id=ispyb_ids.data_collection_group_id,
+        )
         return ispyb_ids
 
     def end_deposition(self, ispyb_ids: IspybIds, success: str, reason: str):
@@ -134,24 +124,19 @@ class StoreInIspyb:
                 run_status = "DataCollection Successful"
             current_time = get_current_time_string()
             self._update_scan_with_end_time_and_status(
-                current_time,
-                run_status,
-                reason,
-                id_,
-                ispyb_ids.data_collection_group_id,
+                current_time, run_status, reason, id_
             )
 
     def append_to_comment(
         self, data_collection_id: int, comment: str, delimiter: str = " "
     ) -> None:
         try:
-            with ispyb.open(self.ISPYB_CONFIG_PATH) as conn:
-                assert conn is not None, "Failed to connect to ISPyB!"
-                mx_acquisition: MXAcquisition = conn.mx_acquisition
-                mx_acquisition.update_data_collection_append_comments(
-                    data_collection_id, comment, delimiter
-                )
-        except ispyb.ReadWriteError as e:
+            self._expeye.update_data_collection(
+                data_collection_id,
+                DataCollectionInfo(comments=delimiter + comment),
+                True,
+            )
+        except ISPyBDepositionNotMadeError as e:
             ISPYB_ZOCALO_CALLBACK_LOGGER.warning(
                 f"Unable to log comment, comment probably exceeded column length: {comment}",
                 exc_info=e,
@@ -162,143 +147,68 @@ class StoreInIspyb:
         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,
-            )
+        self._store_data_collection_group_table(dcg_info, data_collection_group_id)
 
     def _update_scan_with_end_time_and_status(
-        self,
-        end_time: str,
-        run_status: str,
-        reason: str,
-        data_collection_id: int,
-        data_collection_group_id: int,
+        self, end_time: str, run_status: str, reason: str, data_collection_id: int
     ) -> None:
-        if reason is not None and reason != "":
+        if reason != "":
             self.append_to_comment(data_collection_id, f"{run_status} reason: {reason}")
 
-        with ispyb.open(self.ISPYB_CONFIG_PATH) as conn:
-            assert conn is not None, "Failed to connect to ISPyB!"
-
-            mx_acquisition: MXAcquisition = conn.mx_acquisition
-
-            params = mx_acquisition.get_data_collection_params()
-            params["id"] = data_collection_id
-            params["parentid"] = data_collection_group_id
-            params["endtime"] = end_time
-            params["run_status"] = run_status
-            mx_acquisition.upsert_data_collection(list(params.values()))
-
-    def _store_position_table(
-        self, conn: Connector, dc_pos_info, data_collection_id
-    ) -> int:
-        mx_acquisition: MXAcquisition = conn.mx_acquisition
-
-        params = mx_acquisition.get_dc_position_params()
-        params["id"] = data_collection_id
-        params |= asdict(dc_pos_info)
-
-        return mx_acquisition.update_dc_position(list(params.values()))
+        info = DataCollectionInfo(end_time=end_time, run_status=run_status)
+        self._expeye.update_data_collection(data_collection_id, info)
 
     def _store_data_collection_group_table(
         self,
-        conn: Connector,
         dcg_info: DataCollectionGroupInfo,
         data_collection_group_id: int | None = None,
     ) -> int:
-        mx_acquisition: MXAcquisition = conn.mx_acquisition
-
-        params = mx_acquisition.get_data_collection_group_params()
         if data_collection_group_id:
-            params["id"] = data_collection_group_id
-        params["parent_id"] = get_session_id_from_visit(conn, dcg_info.visit_string)
-        params |= {k: v for k, v in asdict(dcg_info).items() if k != "visit_string"}
-
-        return self._upsert_data_collection_group(conn, params)
+            self._expeye.update_data_group(data_collection_group_id, dcg_info)
+            return data_collection_group_id
+        else:
+            proposal, session = get_proposal_and_session_from_visit_string(
+                dcg_info.visit_string
+            )
+            return self._expeye.create_data_group(proposal, session, dcg_info)
 
     def _store_data_collection_table(
-        self, conn, data_collection_id, data_collection_info
-    ):
+        self, data_collection_id, data_collection_info: DataCollectionInfo
+    ) -> int:
         if data_collection_id and data_collection_info.comments:
             self.append_to_comment(
                 data_collection_id, data_collection_info.comments, " "
             )
             data_collection_info.comments = None
 
-        params = self._fill_common_data_collection_params(
-            conn, data_collection_id, data_collection_info
-        )
-
-        return self._upsert_data_collection(conn, params)
+        if data_collection_id:
+            self._expeye.update_data_collection(
+                data_collection_id, data_collection_info
+            )
+            return data_collection_id
+        else:
+            assert data_collection_info.parent_id, (
+                "Data Collection must have a Data Collection Group"
+            )
+            return self._expeye.create_data_collection(
+                data_collection_info.parent_id, data_collection_info
+            )
 
     def _store_single_scan_data(
-        self, conn, scan_data_info, data_collection_id=None
+        self, scan_data_info, data_collection_id=None
     ) -> tuple[int, int | None]:
         data_collection_id = self._store_data_collection_table(
-            conn, data_collection_id, scan_data_info.data_collection_info
+            data_collection_id, scan_data_info.data_collection_info
         )
 
         if scan_data_info.data_collection_position_info:
-            self._store_position_table(
-                conn,
-                scan_data_info.data_collection_position_info,
-                data_collection_id,
+            self._expeye.create_position(
+                data_collection_id, scan_data_info.data_collection_position_info
             )
 
         grid_id = None
         if scan_data_info.data_collection_grid_info:
-            grid_id = self._store_grid_info_table(
-                conn,
-                data_collection_id,
-                scan_data_info.data_collection_grid_info,
+            grid_id = self._expeye.create_grid(
+                data_collection_id, scan_data_info.data_collection_grid_info
             )
         return data_collection_id, grid_id
-
-    def _store_grid_info_table(
-        self,
-        conn: Connector,
-        ispyb_data_collection_id: int,
-        dc_grid_info: DataCollectionGridInfo,
-    ) -> int:
-        mx_acquisition: MXAcquisition = conn.mx_acquisition
-        params = mx_acquisition.get_dc_grid_params()
-        params |= dc_grid_info.as_dict()
-        params["parentid"] = ispyb_data_collection_id
-        return mx_acquisition.upsert_dc_grid(list(params.values()))
-
-    def _fill_common_data_collection_params(
-        self, conn, data_collection_id, data_collection_info: DataCollectionInfo
-    ) -> StrictOrderedDict:
-        mx_acquisition: MXAcquisition = conn.mx_acquisition
-        params = mx_acquisition.get_data_collection_params()
-
-        if data_collection_id:
-            params["id"] = data_collection_id
-        if data_collection_info.visit_string:
-            # This is only needed for populating the DataCollectionGroup
-            params["visit_id"] = get_session_id_from_visit(
-                conn, data_collection_info.visit_string
-            )
-        params |= {
-            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
-
-    @staticmethod
-    @TRACER.start_as_current_span("_upsert_data_collection_group")
-    def _upsert_data_collection_group(
-        conn: Connector, params: StrictOrderedDict
-    ) -> int:
-        return conn.mx_acquisition.upsert_data_collection_group(list(params.values()))
-
-    @staticmethod
-    @TRACER.start_as_current_span("_upsert_data_collection")
-    def _upsert_data_collection(conn: Connector, params: StrictOrderedDict) -> int:
-        return conn.mx_acquisition.upsert_data_collection(list(params.values()))

mx_bluesky/common/external_interaction/ispyb/ispyb_utils.py

@@ -1,12 +1,6 @@
-from __future__ import annotations
-
 import datetime
 import os
 
-from ispyb import NoResult
-from ispyb.connector.mysqlsp.main import ISPyBMySQLSPConnector as Connector
-from ispyb.sp.core import Core
-
 
 def get_ispyb_config() -> str:
     ispyb_config = os.environ.get("ISPYB_CONFIG_PATH")
@@ -14,14 +8,6 @@ def get_ispyb_config() -> str:
     return ispyb_config
 
 
-def get_session_id_from_visit(conn: Connector, visit: str):
-    try:
-        core: Core = conn.core
-        return core.retrieve_visit_id(visit)
-    except NoResult as e:
-        raise NoResult(f"No session ID found in ispyb for visit {visit}") from e
-
-
 def get_current_time_string():
     now = datetime.datetime.now()
     return now.strftime("%Y-%m-%d %H:%M:%S")

mx_bluesky/common/parameters/components.py

@@ -171,6 +171,7 @@ class DiffractionExperiment(
     ispyb_experiment_type: IspybExperimentType
     storage_directory: str
     use_roi_mode: bool = Field(default=GridscanParamConstants.USE_ROI)
+    snapshot_directory: Path = None  # type:ignore # filled in on validation
 
     @model_validator(mode="before")
     @classmethod

mx_bluesky/common/parameters/constants.py

@@ -40,6 +40,8 @@ def _get_oav_config_json_path():
         return "tests/test_data/test_OAVCentring.json"
     elif BEAMLINE == "i03":
         return f"/dls_sw/{BEAMLINE}/software/daq_configuration/json/OAVCentring_hyperion.json"
+    elif BEAMLINE == "aithre":
+        return "/dls/science/groups/i23/aithre/daq_configuration/json/OAVCentring_aithre.json"
     else:
         return f"/dls_sw/{BEAMLINE}/software/daq_configuration/json/OAVCentring.json"
 
@@ -85,8 +87,9 @@ class HardwareConstants:
     OAV_REFRESH_DELAY = 0.3
     PANDA_FGS_RUN_UP_DEFAULT = 0.17
     CRYOJET_MARGIN_MM = 0.2
-    THAWING_TIME = 40
     TIP_OFFSET_UM = 0
+    MAX_CRYO_TEMP_K = 110
+    MAX_CRYO_PRESSURE_BAR = 0.1
 
     # Value quoted in https://www.dectris.com/en/detectors/x-ray-detectors/eiger2/eiger2-for-synchrotrons/eiger2-x/,
     # causes dropped frames, so increase value for safety
@@ -163,7 +166,7 @@ class Status(Enum):
 
 
 @dataclass
-class FeatureSetting: ...  # List of features and their default values. Subclasses must also be a pydantic dataclass
+class FeatureSettings: ...  # List of features and their default values. Subclasses must also be a pydantic dataclass
 
 
 class FeatureSettingSources(

mx_bluesky/common/parameters/device_composites.py

@@ -4,6 +4,7 @@ from dodal.devices.aperturescatterguard import (
 )
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
+from dodal.devices.beamsize.beamsize import BeamsizeBase
 from dodal.devices.common_dcm import DoubleCrystalMonochromator
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
@@ -18,7 +19,7 @@ from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra.zebra import Zebra
 from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
@@ -51,6 +52,7 @@ class GridDetectThenXRayCentreComposite(FlyScanEssentialDevices):
     attenuator: BinaryFilterAttenuator
     backlight: Backlight
     beamstop: Beamstop
+    beamsize: BeamsizeBase
     dcm: DoubleCrystalMonochromator
     detector_motion: DetectorMotion
     zebra_fast_grid_scan: ZebraFastGridScanThreeD
@@ -58,7 +60,7 @@ class GridDetectThenXRayCentreComposite(FlyScanEssentialDevices):
     oav: OAV
     pin_tip_detection: PinTipDetection
     s4_slit_gaps: S4SlitGaps
-    undulator: Undulator
+    undulator: UndulatorInKeV
     xbpm_feedback: XBPMFeedback
     zebra: Zebra
     robot: BartRobot

mx_bluesky/common/utils/exceptions.py

@@ -16,12 +16,27 @@ class WarningError(
     pass
 
 
+class BeamlineCheckFailureError(Exception):
+    """
+    An error which is raised during a beamline check to indicate that the check did
+    not pass.
+    """
+
+    ...
+
+
 class ISPyBDepositionNotMadeError(Exception):
     """Raised when the ISPyB or Zocalo callbacks can't access ISPyB deposition numbers."""
 
     pass
 
 
+class BeamlineStateError(Exception):
+    """Exception raised when the beamline is in the incorrect state"""
+
+    pass
+
+
 class SampleError(WarningError):
     """An exception which identifies an issue relating to the sample."""
 

mx_bluesky/common/utils/log.py

@@ -1,3 +1,4 @@
+import json
 import logging
 from logging.handlers import TimedRotatingFileHandler
 from os import environ
@@ -27,6 +28,14 @@ ALL_LOGGERS = [LOGGER, ISPYB_ZOCALO_CALLBACK_LOGGER, NEXUS_LOGGER]
 __logger_handlers: DodalLogHandlers | None = None
 
 
+def format_doc_for_log(doc):
+    class _BestEffortEncoder(json.JSONEncoder):
+        def default(self, o):
+            return repr(o)
+
+    return json.dumps(doc, indent=2, cls=_BestEffortEncoder)
+
+
 class ExperimentMetadataTagFilter(logging.Filter):
     """When an instance of this custom filter is added to a logging handler, dc_group_id
     and run_id will be tagged in that handlers' log messages."""