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

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

mx_bluesky/{hyperion → common}/external_interaction/nexus/nexus_utils.py

@@ -2,16 +2,27 @@ from __future__ import annotations
 
 import time
 from datetime import UTC, datetime, timedelta
+from enum import Enum
 
 import numpy as np
 from dodal.devices.detector import DetectorParams
-from dodal.devices.zebra import RotationDirection
 from nexgen.nxs_utils import Attenuator, Axis, Beam, Detector, EigerDetector, Goniometer
 from nexgen.nxs_utils.axes import TransformationType
 from numpy.typing import DTypeLike
 
-from mx_bluesky.hyperion.log import NEXUS_LOGGER
-from mx_bluesky.hyperion.utils.utils import convert_eV_to_angstrom
+from mx_bluesky.common.utils.log import NEXUS_LOGGER
+from mx_bluesky.common.utils.utils import convert_eV_to_angstrom
+
+
+class AxisDirection(Enum):
+    """
+    Identifies whether the omega axis of rotation is on the positive x-axis or
+    negative x-axis as per the Nexus standard:
+    https://journals.iucr.org/m/issues/2020/05/00/ti5018/ti5018.pdf
+    """
+
+    POSITIVE = 1
+    NEGATIVE = -1
 
 
 def vds_type_based_on_bit_depth(detector_bit_depth: int) -> DTypeLike:
@@ -35,8 +46,8 @@ def create_goniometer_axes(
     x_y_z_increments: tuple[float, float, float] = (0.0, 0.0, 0.0),
     chi: float = 0.0,
     phi: float = 0.0,
-    rotation_direction: RotationDirection = RotationDirection.NEGATIVE,
-):
+    omega_axis_direction: AxisDirection = AxisDirection.NEGATIVE,
+) -> Goniometer:
     """Returns a Nexgen 'Goniometer' object with the dependency chain of I03's Smargon
     goniometer. If scan points is provided these values will be used in preference to
     those from the params object.
@@ -50,13 +61,17 @@ def create_goniometer_axes(
         x_y_z_increments:    optionally, specify the increments between each image for
                              the x, y, and z axes. Will be ignored if scan_points
                              is provided.
+        omega_axis_direction:      The direction of the omega axis, this determines the
+                             coordinate space parity
+    Returns:
+        The created Goniometer object
     """
     gonio_axes = [
         Axis(
             "omega",
             ".",
             TransformationType.ROTATION,
-            (1.0 * rotation_direction.multiplier, 0.0, 0.0),
+            (1.0 * omega_axis_direction.value, 0.0, 0.0),
             omega_start,
         ),
         Axis(

mx_bluesky/{hyperion → common}/external_interaction/nexus/write_nexus.py

@@ -8,19 +8,19 @@ from __future__ import annotations
 import math
 from pathlib import Path
 
-from dodal.devices.zebra import RotationDirection
 from dodal.utils import get_beamline_name
 from nexgen.nxs_utils import Attenuator, Beam, Detector, Goniometer, Source
 from nexgen.nxs_write.nxmx_writer import NXmxFileWriter
 from numpy.typing import DTypeLike
 from scanspec.core import AxesPoints
 
-from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
-from mx_bluesky.hyperion.external_interaction.nexus.nexus_utils import (
+from mx_bluesky.common.external_interaction.nexus.nexus_utils import (
+    AxisDirection,
     create_detector_parameters,
     create_goniometer_axes,
     get_start_and_predicted_end_time,
 )
+from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
 
 
 class NexusWriter:
@@ -39,7 +39,7 @@ class NexusWriter:
         # detector arming event:
         full_num_of_images: int | None = None,
         meta_data_run_number: int | None = None,
-        rotation_direction: RotationDirection = RotationDirection.NEGATIVE,
+        axis_direction: AxisDirection = AxisDirection.NEGATIVE,
     ) -> None:
         self.beam: Beam | None = None
         self.attenuator: Attenuator | None = None
@@ -69,7 +69,7 @@ class NexusWriter:
             self.scan_points,
             chi=chi_start_deg,
             phi=phi_start_deg,
-            rotation_direction=rotation_direction,
+            omega_axis_direction=axis_direction,
         )
 
     def create_nexus_file(self, bit_depth: DTypeLike):

mx_bluesky/common/external_interaction/test_config_server.py

@@ -0,0 +1,38 @@
+from functools import cache
+
+import pytest
+
+from mx_bluesky.common.external_interaction.config_server import FeatureFlags
+
+
+class MockConfigServer:
+    def best_effort_get_all_feature_flags(self):
+        return {
+            "feature_a": False,
+            "feature_b": False,
+        }
+
+
+class FakeFeatureFlags(FeatureFlags):
+    @staticmethod
+    @cache
+    def get_config_server() -> MockConfigServer:  # type: ignore
+        return MockConfigServer()
+
+    feature_a: bool = False
+    feature_b: bool = False
+
+
+@pytest.fixture
+def fake_feature_flags():
+    return FakeFeatureFlags(feature_a=False, feature_b=False)
+
+
+def test_valid_overridden_features(fake_feature_flags: FakeFeatureFlags):
+    assert fake_feature_flags.feature_a is False
+    assert fake_feature_flags.feature_b is False
+
+
+def test_invalid_overridden_features():
+    with pytest.raises(ValueError, match="Invalid feature toggle"):
+        FakeFeatureFlags(feature_x=True)  # type: ignore

mx_bluesky/common/parameters/components.py

@@ -29,7 +29,7 @@ from mx_bluesky.common.parameters.constants import (
     GridscanParamConstants,
 )
 
-PARAMETER_VERSION = Version.parse("5.2.0")
+PARAMETER_VERSION = Version.parse("5.3.0")
 
 
 class RotationAxis(StrEnum):
@@ -83,6 +83,7 @@ class IspybExperimentType(StrEnum):
     STILL = "Still"
     SSX_CHIP = "SSX-Chip"
     SSX_JET = "SSX-Jet"
+    METAL_ID = "Metal ID"
 
     # Aliases for historic hyperion experiment type mapping
     ROTATION = "SAD"
@@ -92,7 +93,6 @@ class IspybExperimentType(StrEnum):
 
 class MxBlueskyParameters(BaseModel):
     model_config = ConfigDict(
-        arbitrary_types_allowed=True,
         extra="allow",
     )
 
@@ -104,12 +104,12 @@ class MxBlueskyParameters(BaseModel):
     @field_validator("parameter_model_version")
     @classmethod
     def _validate_version(cls, version: SemanticVersion):
-        assert (
-            version >= SemanticVersion(major=PARAMETER_VERSION.major)
-        ), f"Parameter version too old! This version of hyperion uses {PARAMETER_VERSION}"
-        assert (
-            version <= SemanticVersion(major=PARAMETER_VERSION.major + 1)
-        ), f"Parameter version too new! This version of hyperion uses {PARAMETER_VERSION}"
+        assert version >= SemanticVersion(major=PARAMETER_VERSION.major), (
+            f"Parameter version too old! This version of hyperion uses {PARAMETER_VERSION}"
+        )
+        assert version <= SemanticVersion(major=PARAMETER_VERSION.major + 1), (
+            f"Parameter version too new! This version of hyperion uses {PARAMETER_VERSION}"
+        )
         return version
 
 
@@ -150,6 +150,7 @@ class DiffractionExperiment(
     transmission_frac: float = Field(default=0.1)
     ispyb_experiment_type: IspybExperimentType
     storage_directory: str
+    use_roi_mode: bool = Field(default=GridscanParamConstants.USE_ROI)
 
     @model_validator(mode="before")
     @classmethod

mx_bluesky/common/parameters/constants.py

@@ -73,6 +73,7 @@ class HardwareConstants:
     PANDA_FGS_RUN_UP_DEFAULT = 0.17
     CRYOJET_MARGIN_MM = 0.2
     THAWING_TIME = 20
+    TIP_OFFSET_UM = 0
 
 
 @dataclass(frozen=True)

mx_bluesky/common/parameters/gridscan.py

@@ -1,94 +1,148 @@
 from __future__ import annotations
 
-import os
-
 from dodal.devices.aperturescatterguard import ApertureValue
-from dodal.devices.detector import (
-    DetectorParams,
+from dodal.devices.fast_grid_scan import (
+    ZebraGridScanParams,
 )
-from pydantic import Field
+from pydantic import Field, PrivateAttr
+from scanspec.core import Path as ScanPath
+from scanspec.specs import Line, Static
 
 from mx_bluesky.common.parameters.components import (
     DiffractionExperimentWithSample,
     IspybExperimentType,
     OptionalGonioAngleStarts,
+    SplitScan,
+    WithOptionalEnergyChange,
     WithScan,
     XyzStarts,
 )
 from mx_bluesky.common.parameters.constants import (
-    DetectorParamConstants,
     GridscanParamConstants,
     HardwareConstants,
 )
-from mx_bluesky.common.parameters.robot_load import RobotLoadAndEnergyChange
+
+"""Parameter models in this file are abstract. They should be inherited by a top-level model"""
 
 
 class GridCommon(
     DiffractionExperimentWithSample,
     OptionalGonioAngleStarts,
 ):
+    """
+    Parameters used in every MX diffraction experiment using grids. This model should
+    be used by plans which have no knowledge of the grid specifications - i.e before
+    automatic grid detection has completed
+    """
+
+    box_size_um: float = Field(default=GridscanParamConstants.BOX_WIDTH_UM)
     grid_width_um: float = Field(default=GridscanParamConstants.WIDTH_UM)
     exposure_time_s: float = Field(default=GridscanParamConstants.EXPOSURE_TIME_S)
-    use_roi_mode: bool = Field(default=GridscanParamConstants.USE_ROI)
 
     ispyb_experiment_type: IspybExperimentType = Field(
         default=IspybExperimentType.GRIDSCAN_3D
     )
     selected_aperture: ApertureValue | None = Field(default=ApertureValue.SMALL)
 
+    tip_offset_um: float = Field(default=HardwareConstants.TIP_OFFSET_UM)
+
+
+class SpecifiedGrid(XyzStarts, WithScan):
+    """A specified grid is one which has defined values for the start position,
+    grid and box sizes, etc., as opposed to parameters for a plan which will create
+    those parameters at some point (e.g. through optical pin detection)."""
+
+
+class SpecifiedThreeDGridScan(
+    GridCommon,
+    SpecifiedGrid,
+    SplitScan,
+    WithOptionalEnergyChange,
+):
+    """Parameters representing a so-called 3D grid scan, which consists of doing a
+    gridscan in X and Y, followed by one in X and Z."""
+
+    grid1_omega_deg: float = Field(default=GridscanParamConstants.OMEGA_1)  # type: ignore
+    grid2_omega_deg: float = Field(default=GridscanParamConstants.OMEGA_2)
+    x_step_size_um: float = Field(default=GridscanParamConstants.BOX_WIDTH_UM)
+    y_step_size_um: float = Field(default=GridscanParamConstants.BOX_WIDTH_UM)
+    z_step_size_um: float = Field(default=GridscanParamConstants.BOX_WIDTH_UM)
+    y2_start_um: float
+    z2_start_um: float
+    x_steps: int = Field(gt=0)
+    y_steps: int = Field(gt=0)
+    z_steps: int = Field(gt=0)
+    _set_stub_offsets: bool = PrivateAttr(default_factory=lambda: False)
+
     @property
-    def detector_params(self):
-        self.det_dist_to_beam_converter_path = (
-            self.det_dist_to_beam_converter_path
-            or DetectorParamConstants.BEAM_XY_LUT_PATH
-        )
-        optional_args = {}
-        if self.run_number:
-            optional_args["run_number"] = self.run_number
-        assert (
-            self.detector_distance_mm is not None
-        ), "Detector distance must be filled before generating DetectorParams"
-        os.makedirs(self.storage_directory, exist_ok=True)
-        return DetectorParams(
-            detector_size_constants=DetectorParamConstants.DETECTOR,
-            expected_energy_ev=self.demand_energy_ev,
-            exposure_time=self.exposure_time_s,
-            directory=self.storage_directory,
-            prefix=self.file_name,
-            detector_distance=self.detector_distance_mm,
-            omega_start=self.omega_start_deg or 0,
-            omega_increment=0,
-            num_images_per_trigger=1,
-            num_triggers=self.num_images,
-            use_roi_mode=self.use_roi_mode,
-            det_dist_to_beam_converter_path=self.det_dist_to_beam_converter_path,
-            trigger_mode=self.trigger_mode,
-            **optional_args,
+    def FGS_params(self) -> ZebraGridScanParams:
+        return ZebraGridScanParams(
+            x_steps=self.x_steps,
+            y_steps=self.y_steps,
+            z_steps=self.z_steps,
+            x_step_size_mm=self.x_step_size_um / 1000,
+            y_step_size_mm=self.y_step_size_um / 1000,
+            z_step_size_mm=self.z_step_size_um / 1000,
+            x_start_mm=self.x_start_um / 1000,
+            y1_start_mm=self.y_start_um / 1000,
+            z1_start_mm=self.z_start_um / 1000,
+            y2_start_mm=self.y2_start_um / 1000,
+            z2_start_mm=self.z2_start_um / 1000,
+            set_stub_offsets=self._set_stub_offsets,
+            dwell_time_ms=self.exposure_time_s * 1000,
+            transmission_fraction=self.transmission_frac,
         )
 
+    def do_set_stub_offsets(self, value: bool):
+        self._set_stub_offsets = value
 
-class RobotLoadThenCentre(GridCommon):
-    thawing_time: float = Field(default=HardwareConstants.THAWING_TIME)
-
-    def robot_load_params(self):
-        my_params = self.model_dump()
-        return RobotLoadAndEnergyChange(**my_params)
+    @property
+    def grid_1_spec(self):
+        x_end = self.x_start_um + self.x_step_size_um * (self.x_steps - 1)
+        y1_end = self.y_start_um + self.y_step_size_um * (self.y_steps - 1)
+        grid_1_x = Line("sam_x", self.x_start_um, x_end, self.x_steps)
+        grid_1_y = Line("sam_y", self.y_start_um, y1_end, self.y_steps)
+        grid_1_z = Static("sam_z", self.z_start_um)
+        return grid_1_y.zip(grid_1_z) * ~grid_1_x
 
-    def pin_centre_then_xray_centre_params(self):
-        my_params = self.model_dump()
-        del my_params["thawing_time"]
-        return PinTipCentreThenXrayCentre(**my_params)
+    @property
+    def grid_2_spec(self):
+        x_end = self.x_start_um + self.x_step_size_um * (self.x_steps - 1)
+        z2_end = self.z2_start_um + self.z_step_size_um * (self.z_steps - 1)
+        grid_2_x = Line("sam_x", self.x_start_um, x_end, self.x_steps)
+        grid_2_z = Line("sam_z", self.z2_start_um, z2_end, self.z_steps)
+        grid_2_y = Static("sam_y", self.y2_start_um)
+        return grid_2_z.zip(grid_2_y) * ~grid_2_x
 
+    @property
+    def scan_indices(self):
+        """The first index of each gridscan, useful for writing nexus files/VDS"""
+        return [
+            0,
+            len(ScanPath(self.grid_1_spec.calculate()).consume().midpoints["sam_x"]),
+        ]
 
-class GridScanWithEdgeDetect(GridCommon):
-    box_size_um: float = Field(default=GridscanParamConstants.BOX_WIDTH_UM)
+    @property
+    def scan_spec(self):
+        """A fully specified ScanSpec object representing both grids, with x, y, z and
+        omega positions."""
+        return self.grid_1_spec.concat(self.grid_2_spec)
 
+    @property
+    def scan_points(self):
+        """A list of all the points in the scan_spec."""
+        return ScanPath(self.scan_spec.calculate()).consume().midpoints
 
-class PinTipCentreThenXrayCentre(GridCommon):
-    tip_offset_um: float = 0
+    @property
+    def scan_points_first_grid(self):
+        """A list of all the points in the first grid scan."""
+        return ScanPath(self.grid_1_spec.calculate()).consume().midpoints
 
+    @property
+    def scan_points_second_grid(self):
+        """A list of all the points in the second grid scan."""
+        return ScanPath(self.grid_2_spec.calculate()).consume().midpoints
 
-class SpecifiedGrid(XyzStarts, WithScan):
-    """A specified grid is one which has defined values for the start position,
-    grid and box sizes, etc., as opposed to parameters for a plan which will create
-    those parameters at some point (e.g. through optical pin detection)."""
+    @property
+    def num_images(self) -> int:
+        return len(self.scan_points["sam_x"])

mx_bluesky/common/plans/do_fgs.py

@@ -18,9 +18,7 @@ from mx_bluesky.common.device_setup_plans.read_hardware_for_setup import (
     read_hardware_for_zocalo,
 )
 from mx_bluesky.common.parameters.constants import (
-    EnvironmentConstants,
     PlanNameConstants,
-    TriggerConstants,
 )
 from mx_bluesky.common.utils.tracing import TRACER
 
@@ -59,7 +57,7 @@ def _wait_for_zocalo_to_stage_then_do_fgs(
     yield from bps.complete(grid_scan_device, wait=True)
     # Remove this logging statement once metrics have been added
     LOGGER.info(
-        f"Grid scan motion program took {round(time()-gridscan_start_time,2)} to complete"
+        f"Grid scan motion program took {round(time() - gridscan_start_time, 2)} to complete"
     )
 
 
@@ -70,7 +68,6 @@ def kickoff_and_complete_gridscan(
     scan_points: list[AxesPoints[Axis]],
     scan_start_indices: list[int],
     plan_during_collection: Callable[[], MsgGenerator] | None = None,
-    zocalo_environment: str = EnvironmentConstants.ZOCALO_ENV,
 ):
     """Triggers a grid scan motion program and waits for completion, accounting for synchrotron topup.
     If the RunEngine is subscribed to ZocaloCallback, this plan will also trigger Zocalo.
@@ -86,12 +83,11 @@ def kickoff_and_complete_gridscan(
         scan_start_indices (list[int]):         Contains the first index of each grid scan
         plan_during_collection (Optional, MsgGenerator): Generic plan called in between kickoff and completion,
                                                 eg waiting on zocalo.
-        zocalo_environment (Optional, str)      Used for zocalo connection
     """
 
-    assert len(scan_points) == len(
-        scan_start_indices
-    ), "scan_points and scan_start_indices must be lists of the same length!"
+    assert len(scan_points) == len(scan_start_indices), (
+        "scan_points and scan_start_indices must be lists of the same length!"
+    )
 
     plan_name = PlanNameConstants.DO_FGS
 
@@ -100,10 +96,8 @@ def kickoff_and_complete_gridscan(
     @bpp.run_decorator(
         md={
             "subplan_name": plan_name,
-            TriggerConstants.ZOCALO: plan_name,
             "scan_points": scan_points,
             "scan_start_indices": scan_start_indices,
-            "zocalo_environment": zocalo_environment,
         }
     )
     @bpp.contingency_decorator(

mx_bluesky/{hyperion → common/utils}/exceptions.py

@@ -1,3 +1,4 @@
+import re
 from collections.abc import Callable, Generator
 from typing import TypeVar
 
@@ -13,10 +14,23 @@ class WarningException(Exception):
     pass
 
 
+class ISPyBDepositionNotMade(Exception):
+    """Raised when the ISPyB or Zocalo callbacks can't access ISPyB deposition numbers."""
+
+    pass
+
+
 class SampleException(WarningException):
     """An exception which identifies an issue relating to the sample."""
 
-    pass
+    def __str__(self):
+        class_name = type(self).__name__
+        return f"[{class_name}]: {super().__str__()}"
+
+    @classmethod
+    def type_and_message_from_reason(cls, reason: str) -> tuple[str, str]:
+        match = re.match(r"\[(\S*)?]: (.*)", reason)
+        return (match.group(1), match.group(2)) if match else (None, None)
 
 
 T = TypeVar("T")

mx_bluesky/common/utils/log.py

@@ -12,7 +12,17 @@ from dodal.log import (
 )
 from dodal.log import LOGGER as dodal_logger
 
-LOGGER = logging.getLogger("mx-bluesky")
+LOGGER = logging.getLogger("MX-Bluesky")
+LOGGER.setLevel("DEBUG")
+LOGGER.parent = dodal_logger
+
+ISPYB_ZOCALO_CALLBACK_LOGGER = logging.getLogger("ISPyB and Zocalo callbacks")
+ISPYB_ZOCALO_CALLBACK_LOGGER.setLevel(logging.DEBUG)
+
+NEXUS_LOGGER = logging.getLogger("NeXus callbacks")
+NEXUS_LOGGER.setLevel(logging.DEBUG)
+
+ALL_LOGGERS = [LOGGER, ISPYB_ZOCALO_CALLBACK_LOGGER, NEXUS_LOGGER]
 
 __logger_handlers: DodalLogHandlers | None = None
 
@@ -76,18 +86,18 @@ def do_default_logging_setup(
 
 
 def _get_debug_handler() -> CircularMemoryHandler:
-    assert (
-        __logger_handlers is not None
-    ), "You can only use this after running the default logging setup"
+    assert __logger_handlers is not None, (
+        "You can only use this after running the default logging setup"
+    )
     return __logger_handlers["debug_memory_handler"]
 
 
 def flush_debug_handler() -> str:
     """Writes the contents of the circular debug log buffer to disk and returns the written filename"""
     handler = _get_debug_handler()
-    assert isinstance(
-        handler.target, TimedRotatingFileHandler
-    ), "Circular memory handler doesn't have an appropriate fileHandler target"
+    assert isinstance(handler.target, TimedRotatingFileHandler), (
+        "Circular memory handler doesn't have an appropriate fileHandler target"
+    )
     handler.flush()
     return handler.target.baseFilename