mx-bluesky 1.5.10__py3-none-any.whl → 1.5.12__py3-none-any.whl

mx_bluesky/hyperion/experiment_plans/rotation_scan_plan.py

@@ -10,6 +10,7 @@ from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
+from dodal.devices.beamsize.beamsize import BeamsizeBase
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.flux import Flux
@@ -21,7 +22,8 @@ from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import CombinedMove, Smargon
 from dodal.devices.synchrotron import Synchrotron
-from dodal.devices.undulator import Undulator
+from dodal.devices.thawer import Thawer
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra.zebra import RotationDirection, Zebra
 from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
@@ -49,7 +51,7 @@ from mx_bluesky.common.experiment_plans.inner_plans.read_hardware import (
 from mx_bluesky.common.experiment_plans.oav_snapshot_plan import (
     OavSnapshotComposite,
     oav_snapshot_plan,
-    setup_beamline_for_OAV,
+    setup_beamline_for_oav,
 )
 from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.common.preprocessors.preprocessors import (
@@ -74,6 +76,7 @@ class RotationScanComposite(OavSnapshotComposite):
     aperture_scatterguard: ApertureScatterguard
     attenuator: BinaryFilterAttenuator
     backlight: Backlight
+    beamsize: BeamsizeBase
     beamstop: Beamstop
     dcm: DCM
     detector_motion: DetectorMotion
@@ -81,13 +84,14 @@ class RotationScanComposite(OavSnapshotComposite):
     flux: Flux
     robot: BartRobot
     smargon: Smargon
-    undulator: Undulator
+    undulator: UndulatorInKeV
     synchrotron: Synchrotron
     s4_slit_gaps: S4SlitGaps
     sample_shutter: ZebraShutter
     zebra: Zebra
     oav: OAV
     xbpm_feedback: XBPMFeedback
+    thawer: Thawer
 
 
 def create_devices(context: BlueskyContext) -> RotationScanComposite:
@@ -258,6 +262,7 @@ def rotation_scan_plan(
             composite.aperture_scatterguard,
             params.selected_aperture,
             composite.backlight,
+            composite.thawer,
             group=CONST.WAIT.ROTATION_READY_FOR_DC,
         )
 
@@ -301,6 +306,7 @@ def rotation_scan_plan(
             composite.flux,
             composite.dcm,
             composite.eiger,
+            composite.beamsize,
         )
 
     yield from _rotation_scan_plan(motion_values, composite)
@@ -346,7 +352,7 @@ def _move_and_rotation(
         yield from bps.wait(CONST.WAIT.MOVE_GONIO_TO_START)
 
         if not params.use_grid_snapshots:
-            yield from setup_beamline_for_OAV(
+            yield from setup_beamline_for_oav(
                 composite.smargon,
                 composite.backlight,
                 composite.aperture_scatterguard,

mx_bluesky/hyperion/experiment_plans/set_energy_plan.py

@@ -12,7 +12,7 @@ from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, MirrorVoltages
 from dodal.devices.i03.dcm import DCM
 from dodal.devices.i03.undulator_dcm import UndulatorDCM
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.xbpm_feedback import XBPMFeedback
 
 from mx_bluesky.common.parameters.constants import PlanNameConstants
@@ -39,7 +39,7 @@ class SetEnergyComposite:
 # Remove composite after https://github.com/DiamondLightSource/dodal/issues/1092
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class XBPMWrapperComposite:
-    undulator: Undulator
+    undulator: UndulatorInKeV
     xbpm_feedback: XBPMFeedback
     attenuator: BinaryFilterAttenuator
     dcm: DCM

mx_bluesky/hyperion/experiment_plans/udc_default_state.py

@@ -0,0 +1,160 @@
+import bluesky.plan_stubs as bps
+import pydantic
+from bluesky.utils import MsgGenerator
+from dodal.common.beamlines.beamline_parameters import (
+    get_beamline_parameters,
+)
+from dodal.devices.aperturescatterguard import ApertureValue
+from dodal.devices.collimation_table import CollimationTable
+from dodal.devices.cryostream import CryoStream, CryoStreamGantry, CryoStreamSelection
+from dodal.devices.cryostream import InOut as CryoInOut
+from dodal.devices.fluorescence_detector_motion import FluorescenceDetector
+from dodal.devices.fluorescence_detector_motion import InOut as FlouInOut
+from dodal.devices.hutch_shutter import HutchShutter, ShutterDemand
+from dodal.devices.mx_phase1.beamstop import BeamstopPositions
+from dodal.devices.robot import BartRobot, PinMounted
+from dodal.devices.scintillator import InOut as ScinInOut
+from dodal.devices.scintillator import Scintillator
+from dodal.devices.smargon import Smargon
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutterState
+
+from mx_bluesky.common.experiment_plans.beamstop_check import (
+    BeamstopCheckDevices,
+    move_beamstop_in_and_verify_using_diode,
+)
+from mx_bluesky.common.utils.exceptions import BeamlineCheckFailureError
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.hyperion.external_interaction.config_server import (
+    get_hyperion_config_client,
+)
+from mx_bluesky.hyperion.parameters.constants import HyperionFeatureSettings
+
+_GROUP_PRE_BEAMSTOP_CHECK = "pre_beamstop_check"
+_GROUP_POST_BEAMSTOP_CHECK = "post_beamstop_check"
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class UDCDefaultDevices(BeamstopCheckDevices):
+    collimation_table: CollimationTable
+    cryostream: CryoStream
+    cryostream_gantry: CryoStreamGantry
+    fluorescence_det_motion: FluorescenceDetector
+    hutch_shutter: HutchShutter
+    robot: BartRobot
+    scintillator: Scintillator
+    smargon: Smargon
+
+
+class UnexpectedSampleError(BeamlineCheckFailureError): ...
+
+
+class CryoStreamError(BeamlineCheckFailureError): ...
+
+
+def move_to_udc_default_state(devices: UDCDefaultDevices):
+    """Moves beamline to known positions prior to UDC start"""
+    yield from _verify_correct_cryostream_selected(devices.cryostream_gantry)
+
+    cryostream_temp = yield from bps.rd(devices.cryostream.temperature_k)
+    cryostream_pressure = yield from bps.rd(devices.cryostream.back_pressure_bar)
+    if cryostream_temp > devices.cryostream.MAX_TEMP_K:
+        raise CryoStreamError("Cryostream temperature is too high, not starting UDC")
+    if cryostream_pressure > devices.cryostream.MAX_PRESSURE_BAR:
+        raise CryoStreamError("Cryostream back pressure is too high, not starting UDC")
+
+    yield from _verify_no_sample_present(devices.robot)
+
+    # Close fast shutter before opening hutch shutter
+    yield from bps.abs_set(devices.sample_shutter, ZebraShutterState.CLOSE, wait=True)
+
+    commissioning_mode_enabled = yield from bps.rd(devices.baton.commissioning)
+
+    if commissioning_mode_enabled:
+        LOGGER.warning("Not opening hutch shutter - commissioning mode is enabled.")
+    else:
+        yield from bps.abs_set(
+            devices.hutch_shutter, ShutterDemand.OPEN, group=_GROUP_PRE_BEAMSTOP_CHECK
+        )
+
+    yield from bps.abs_set(devices.scintillator.selected_pos, ScinInOut.OUT, wait=True)
+
+    yield from bps.abs_set(
+        devices.fluorescence_det_motion.pos,
+        FlouInOut.OUT,
+        group=_GROUP_PRE_BEAMSTOP_CHECK,
+    )
+
+    yield from bps.abs_set(
+        devices.collimation_table.inboard_y,
+        0,
+        group=_GROUP_PRE_BEAMSTOP_CHECK,
+    )
+    yield from bps.abs_set(
+        devices.collimation_table.outboard_y, 0, group=_GROUP_PRE_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.collimation_table.upstream_y, 0, group=_GROUP_PRE_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.collimation_table.upstream_x, 0, group=_GROUP_PRE_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.collimation_table.downstream_x, 0, group=_GROUP_PRE_BEAMSTOP_CHECK
+    )
+
+    # Wait for all of the above to complete
+    yield from bps.wait(group=_GROUP_PRE_BEAMSTOP_CHECK, timeout=0.1)
+
+    feature_flags: HyperionFeatureSettings = (
+        get_hyperion_config_client().get_feature_flags()
+    )
+    if feature_flags.BEAMSTOP_DIODE_CHECK:
+        beamline_parameters = get_beamline_parameters()
+        config_client = get_hyperion_config_client()
+        features_settings: HyperionFeatureSettings = config_client.get_feature_flags()
+        detector_min_z = features_settings.DETECTOR_DISTANCE_LIMIT_MIN_MM
+        detector_max_z = features_settings.DETECTOR_DISTANCE_LIMIT_MAX_MM
+        yield from move_beamstop_in_and_verify_using_diode(
+            devices, beamline_parameters, detector_min_z, detector_max_z
+        )
+    else:
+        yield from bps.abs_set(
+            devices.beamstop.selected_pos, BeamstopPositions.DATA_COLLECTION, wait=True
+        )
+
+    yield from bps.abs_set(
+        devices.aperture_scatterguard.selected_aperture,
+        ApertureValue.SMALL,
+        group=_GROUP_POST_BEAMSTOP_CHECK,
+    )
+
+    yield from bps.abs_set(
+        devices.cryostream.course, CryoInOut.IN, group=_GROUP_POST_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.cryostream.fine, CryoInOut.IN, group=_GROUP_POST_BEAMSTOP_CHECK
+    )
+
+    yield from bps.wait(_GROUP_POST_BEAMSTOP_CHECK)
+
+
+def _verify_correct_cryostream_selected(
+    cryostream_gantry: CryoStreamGantry,
+) -> MsgGenerator:
+    cryostream_selection = yield from bps.rd(cryostream_gantry.cryostream_selector)
+    cryostream_selected = yield from bps.rd(cryostream_gantry.cryostream_selected)
+    if cryostream_selection != CryoStreamSelection.CRYOJET or cryostream_selected != 1:
+        raise CryoStreamError(
+            f"Cryostream is not selected for use, control PV selection = {cryostream_selection}, "
+            f"current status {cryostream_selected}"
+        )
+
+
+def _verify_no_sample_present(robot: BartRobot):
+    pin_mounted = yield from bps.rd(robot.gonio_pin_sensor)
+
+    if pin_mounted != PinMounted.NO_PIN_MOUNTED:
+        # Cannot unload this sample because we do not know the correct visit for it
+        raise UnexpectedSampleError(
+            "An unexpected sample was found, please unload the sample manually."
+        )

mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -23,7 +23,7 @@ from mx_bluesky.common.parameters.constants import (
     GridscanParamConstants,
 )
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.common.utils.utils import convert_angstrom_to_eV
+from mx_bluesky.common.utils.utils import convert_angstrom_to_ev
 from mx_bluesky.hyperion.parameters.components import Wait
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 
@@ -220,9 +220,9 @@ def _get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
 def _get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
     try:
         first_collection: dict = parameters["collection"][0]
-        wavelength = first_collection.get("wavelength")
+        wavelength: float | None = first_collection.get("wavelength")
         assert isinstance(wavelength, float)
-        demand_energy_ev = convert_angstrom_to_eV(wavelength)
+        demand_energy_ev = convert_angstrom_to_ev(wavelength)
         return {"demand_energy_ev": demand_energy_ev}
     except (KeyError, IndexError, AttributeError, TypeError):
         return {"demand_energy_ev": None}

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -5,7 +5,7 @@ from time import sleep  # noqa
 
 from bluesky.callbacks import CallbackBase
 from bluesky.callbacks.zmq import Proxy, RemoteDispatcher
-from dodal.log import LOGGER as dodal_logger
+from dodal.log import LOGGER as DODAL_LOGGER
 from dodal.log import set_up_all_logging_handlers
 
 from mx_bluesky.common.external_interaction.alerting import set_alerting_service
@@ -124,7 +124,7 @@ def setup_logging(dev_mode: bool):
     log_info(f"Loggers initialised with dev_mode={dev_mode}")
     nexgen_logger = logging.getLogger("nexgen")
     nexgen_logger.parent = NEXUS_LOGGER
-    dodal_logger.parent = ISPYB_ZOCALO_CALLBACK_LOGGER
+    DODAL_LOGGER.parent = ISPYB_ZOCALO_CALLBACK_LOGGER
     log_debug("nexgen logger added to nexus logger")
 
 

mx_bluesky/hyperion/external_interaction/callbacks/rotation/ispyb_callback.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Sequence
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from dodal.devices.zocalo import ZocaloStartInfo
 
@@ -46,7 +46,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
     To use, subscribe the Bluesky RunEngine to an instance of this class.
     E.g.:
         ispyb_handler_callback = RotationISPyBCallback(parameters)
-        RE.subscribe(ispyb_handler_callback)
+        run_engine.subscribe(ispyb_handler_callback)
     Or decorate a plan using bluesky.preprocessors.subs_decorator.
 
     See: https://blueskyproject.io/bluesky/callbacks.html#ways-to-invoke-callbacks
@@ -92,7 +92,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
             ISPYB_ZOCALO_CALLBACK_LOGGER.info("Beginning ispyb deposition")
             data_collection_group_info = populate_data_collection_group(self.params)
             data_collection_info = populate_data_collection_info_for_rotation(
-                cast(SingleRotationScan, self.params)
+                self.params
             )
             data_collection_info = populate_remaining_data_collection_info(
                 self.params.comment,

mx_bluesky/hyperion/external_interaction/callbacks/rotation/ispyb_mapping.py

@@ -6,6 +6,7 @@ from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 
 def populate_data_collection_info_for_rotation(params: SingleRotationScan):
     info = DataCollectionInfo(
+        chi_start=params.chi_start_deg,
         omega_start=params.omega_start_deg,
         data_collection_number=params.detector_params.run_number,  # type:ignore # the validator always makes this int
         n_images=params.num_images,

mx_bluesky/hyperion/external_interaction/callbacks/rotation/nexus_callback.py

@@ -2,9 +2,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-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,
 )
@@ -14,7 +11,7 @@ from mx_bluesky.common.external_interaction.nexus.nexus_utils import (
     vds_type_based_on_bit_depth,
 )
 from mx_bluesky.common.external_interaction.nexus.write_nexus import NexusWriter
-from mx_bluesky.common.utils.log import NEXUS_LOGGER
+from mx_bluesky.common.utils.log import NEXUS_LOGGER, format_doc_for_log
 from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 
@@ -29,7 +26,7 @@ class RotationNexusFileCallback(PlanReactiveCallback):
     To use, subscribe the Bluesky RunEngine to an instance of this class.
     E.g.:
         nexus_file_handler_callback = NexusFileCallback(parameters)
-        RE.subscribe(nexus_file_handler_callback)
+        run_engine.subscribe(nexus_file_handler_callback)
     Or decorate a plan using bluesky.preprocessors.subs_decorator.
 
     See: https://blueskyproject.io/bluesky/callbacks.html#ways-to-invoke-callbacks
@@ -65,7 +62,7 @@ class RotationNexusFileCallback(PlanReactiveCallback):
                 self.writer.beam,
                 self.writer.attenuator,
             ) = create_beam_and_attenuator_parameters(
-                data["dcm-energy_in_kev"],
+                data["dcm-energy_in_keV"],
                 data["flux-flux_reading"],
                 data["attenuator-actual_transmission"],
             )

mx_bluesky/hyperion/external_interaction/config_server.py

@@ -2,15 +2,15 @@ from functools import cache
 
 from mx_bluesky.common.external_interaction.config_server import MXConfigClient
 from mx_bluesky.hyperion.parameters.constants import (
-    HyperionFeatureSetting,
-    HyperionFeatureSettingources,
+    HyperionFeatureSettings,
+    HyperionFeatureSettingsSources,
 )
 
 
 @cache
-def get_hyperion_config_client() -> MXConfigClient[HyperionFeatureSetting]:
+def get_hyperion_config_client() -> MXConfigClient[HyperionFeatureSettings]:
     return MXConfigClient(
-        feature_sources=HyperionFeatureSettingources,
-        feature_dc=HyperionFeatureSetting,
+        feature_sources=HyperionFeatureSettingsSources,
+        feature_dc=HyperionFeatureSettings,
         url="https://daq-config.diamond.ac.uk",
     )

mx_bluesky/hyperion/parameters/constants.py

@@ -8,8 +8,8 @@ from mx_bluesky.common.parameters.constants import (
     DocDescriptorNames,
     EnvironmentConstants,
     ExperimentParamConstants,
-    FeatureSetting,
-    FeatureSettingources,
+    FeatureSettings,
+    FeatureSettingSources,
     HardwareConstants,
     OavConstants,
     PlanGroupCheckpointConstants,
@@ -32,20 +32,27 @@ class I03Constants:
 
 
 # These currently exist in GDA domain.properties
-class HyperionFeatureSettingources(FeatureSettingources):
+class HyperionFeatureSettingsSources(FeatureSettingSources):
     USE_GPU_RESULTS = "gda.mx.hyperion.xrc.use_gpu_results"
     USE_PANDA_FOR_GRIDSCAN = "gda.mx.hyperion.use_panda_for_gridscans"
     SET_STUB_OFFSETS = "gda.mx.hyperion.do_stub_offsets"
     PANDA_RUNUP_DISTANCE_MM = "gda.mx.hyperion.panda_runup_distance_mm"
+    DETECTOR_DISTANCE_LIMIT_MAX_MM = "gda.detector.distance.limit.max"
+    DETECTOR_DISTANCE_LIMIT_MIN_MM = "gda.detector.distance.limit.min"
+    BEAMSTOP_DIODE_CHECK = "gda.mx.hyperion.enable_beamstop_diode_check"
 
 
 # Use these defaults if we can't read from the config server
 @dataclass
-class HyperionFeatureSetting(FeatureSetting):
+class HyperionFeatureSettings(FeatureSettings):
     USE_GPU_RESULTS: bool = True
     USE_PANDA_FOR_GRIDSCAN: bool = False
     SET_STUB_OFFSETS: bool = False
     PANDA_RUNUP_DISTANCE_MM: float = 0.16
+    # From GDA mx-config hutch_utilities.py default values
+    DETECTOR_DISTANCE_LIMIT_MAX_MM: float = 700
+    DETECTOR_DISTANCE_LIMIT_MIN_MM: float = 250
+    BEAMSTOP_DIODE_CHECK: bool = False
 
 
 @dataclass(frozen=True)

mx_bluesky/hyperion/parameters/device_composites.py

@@ -16,7 +16,7 @@ from dodal.devices.flux import Flux
 from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 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
@@ -41,7 +41,7 @@ class HyperionFlyScanXRayCentreComposite(FlyScanEssentialDevices):
     eiger: EigerDetector
     flux: Flux
     s4_slit_gaps: S4SlitGaps
-    undulator: Undulator
+    undulator: UndulatorInKeV
     synchrotron: Synchrotron
     zebra: Zebra
     zocalo: ZocaloResults

mx_bluesky/hyperion/parameters/gridscan.py

@@ -44,7 +44,7 @@ class HyperionSpecifiedThreeDGridScan(SpecifiedThreeDGridScan):
 
     # Relative to common grid scan, stub offsets are defined by config server
     @property
-    def FGS_params(self) -> ZebraGridScanParamsThreeD:
+    def fast_gridscan_params(self) -> ZebraGridScanParamsThreeD:
         return ZebraGridScanParamsThreeD(
             x_steps=self.x_steps,
             y_steps=self.y_steps,
@@ -65,10 +65,10 @@ class HyperionSpecifiedThreeDGridScan(SpecifiedThreeDGridScan):
         )
 
     @property
-    def panda_FGS_params(self) -> PandAGridScanParams:
+    def panda_fast_gridscan_params(self) -> PandAGridScanParams:
         if self.y_steps % 2 and self.z_steps > 0:
             # See https://github.com/DiamondLightSource/hyperion/issues/1118 for explanation
-            raise OddYStepsException(
+            raise OddYStepsError(
                 "The number of Y steps must be even for a PandA gridscan"
             )
         return PandAGridScanParams(
@@ -93,7 +93,7 @@ class HyperionSpecifiedThreeDGridScan(SpecifiedThreeDGridScan):
         )
 
 
-class OddYStepsException(Exception): ...
+class OddYStepsError(Exception): ...
 
 
 class PinTipCentreThenXrayCentre(GridCommonWithHyperionDetectorParams):

mx_bluesky/hyperion/parameters/robot_load.py

@@ -1,5 +1,3 @@
-from pydantic import Field
-
 from mx_bluesky.common.parameters.components import (
     MxBlueskyParameters,
     WithOptionalEnergyChange,
@@ -7,9 +5,6 @@ from mx_bluesky.common.parameters.components import (
     WithSnapshot,
     WithVisit,
 )
-from mx_bluesky.common.parameters.constants import (
-    HardwareConstants,
-)
 from mx_bluesky.hyperion.parameters.gridscan import (
     GridCommonWithHyperionDetectorParams,
     PinTipCentreThenXrayCentre,
@@ -19,12 +14,10 @@ from mx_bluesky.hyperion.parameters.gridscan import (
 class RobotLoadAndEnergyChange(
     MxBlueskyParameters, WithSample, WithSnapshot, WithOptionalEnergyChange, WithVisit
 ):
-    thawing_time: float = Field(default=HardwareConstants.THAWING_TIME)
+    pass
 
 
 class RobotLoadThenCentre(GridCommonWithHyperionDetectorParams):
-    thawing_time: float = Field(default=HardwareConstants.THAWING_TIME)
-
     @property
     def robot_load_params(self) -> RobotLoadAndEnergyChange:
         my_params = self.model_dump()
@@ -33,5 +26,4 @@ class RobotLoadThenCentre(GridCommonWithHyperionDetectorParams):
     @property
     def pin_centre_then_xray_centre_params(self) -> PinTipCentreThenXrayCentre:
         my_params = self.model_dump()
-        del my_params["thawing_time"]
         return PinTipCentreThenXrayCentre(**my_params)

mx_bluesky/hyperion/plan_runner.py

@@ -5,12 +5,12 @@ from blueapi.core import BlueskyContext
 from bluesky.utils import MsgGenerator, RequestAbort
 
 from mx_bluesky.common.parameters.constants import Status
-from mx_bluesky.common.utils.exceptions import WarningException
+from mx_bluesky.common.utils.exceptions import WarningError
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.runner import BaseRunner
 
 
-class PlanException(Exception):
+class PlanError(Exception):
     """Identifies an exception that was encountered during plan execution."""
 
     pass
@@ -32,7 +32,7 @@ class PlanRunner(BaseRunner):
         Args:
             experiment: The experiment to run
         Raises:
-            PlanException: If the plan raised an exception
+            PlanError: If the plan raised an exception
             RequestAbort: If the RunEngine aborted during execution"""
 
         self.current_status = Status.BUSY
@@ -40,7 +40,7 @@ class PlanRunner(BaseRunner):
         try:
             yield from experiment()
             self.current_status = Status.IDLE
-        except WarningException as e:
+        except WarningError as e:
             LOGGER.warning("Plan failed with warning", exc_info=e)
             self.current_status = Status.FAILED
         except RequestAbort:
@@ -50,7 +50,7 @@ class PlanRunner(BaseRunner):
         except Exception as e:
             LOGGER.error("Plan failed with exception", exc_info=e)
             self.current_status = Status.FAILED
-            raise PlanException("Exception thrown in plan execution") from e
+            raise PlanError("Exception thrown in plan execution") from e
 
     def shutdown(self):
         """Performs a prompt shutdown. Aborts the run engine and terminates the loop
@@ -61,7 +61,7 @@ class PlanRunner(BaseRunner):
                 # abort() causes the run engine to throw a RequestAbort exception
                 # inside the plan, which will propagate through the contingency wrappers.
                 # When the plan returns, the run engine will raise RunEngineInterrupted
-                self.RE.abort()
+                self.run_engine.abort()
             except Exception as e:
                 LOGGER.warning(
                     "Exception encountered when issuing abort() to RunEngine:",

mx_bluesky/hyperion/runner.py

@@ -14,7 +14,7 @@ from mx_bluesky.common.external_interaction.callbacks.common.log_uid_tag_callbac
 )
 from mx_bluesky.common.parameters.components import MxBlueskyParameters
 from mx_bluesky.common.parameters.constants import Actions, Status
-from mx_bluesky.common.utils.exceptions import WarningException
+from mx_bluesky.common.utils.exceptions import WarningError
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.utils.tracing import TRACER
 from mx_bluesky.hyperion.experiment_plans.experiment_registry import PLAN_REGISTRY
@@ -65,15 +65,15 @@ class BaseRunner:
 
     def __init__(self, context: BlueskyContext):
         self.context: BlueskyContext = context
-        self.RE = context.run_engine
-        # These references are necessary to maintain liveness of callbacks because RE
+        self.run_engine = context.run_engine
+        # These references are necessary to maintain liveness of callbacks because run_engine
         # only keeps a weakref
         self._logging_uid_tag_callback = LogUidTaggingCallback()
         self._publisher = Publisher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[0]}")
 
-        self.RE.subscribe(self._logging_uid_tag_callback)
+        self.run_engine.subscribe(self._logging_uid_tag_callback)
         LOGGER.info("Connecting to external callback ZMQ proxy...")
-        self.RE.subscribe(self._publisher)
+        self.run_engine.subscribe(self._publisher)
 
 
 class GDARunner(BaseRunner):
@@ -145,7 +145,7 @@ class GDARunner(BaseRunner):
             # abort() causes the run engine to throw a RequestAbort exception
             # inside the plan, which will propagate through the contingency wrappers.
             # When the plan returns, the run engine will raise RunEngineInterrupted
-            self.RE.abort()
+            self.run_engine.abort()
             self.current_status = StatusAndMessage(Status.IDLE)
         except Exception as e:
             self.current_status = make_error_status_and_message(e)
@@ -171,12 +171,14 @@ class GDARunner(BaseRunner):
                     raise ValueError("No experiment provided for START")
                 try:
                     with TRACER.start_span("do_run"):
-                        self.RE(command.experiment(command.devices, command.parameters))
+                        self.run_engine(
+                            command.experiment(command.devices, command.parameters)
+                        )
 
                     self.current_status = StatusAndMessage(Status.IDLE)
 
                     self._last_run_aborted = False
-                except WarningException as exception:
+                except WarningError as exception:
                     LOGGER.warning("Warning Exception", exc_info=True)
                     self.current_status = make_error_status_and_message(exception)
                 except Exception as exception:

mx_bluesky/jupyter_example.ipynb

@@ -18,12 +18,12 @@
     "from bluesky import RunEngine\n",
     "from bluesky.callbacks.best_effort import BestEffortCallback\n",
     "\n",
-    "RE = RunEngine({})\n",
+    "run_engine = RunEngine({})\n",
     "\n",
     "bec = BestEffortCallback()\n",
     "\n",
     "# Send all metadata/data captured to the BestEffortCallback.\n",
-    "RE.subscribe(bec)"
+    "run_engine.subscribe(bec)"
    ]
   },
   {
@@ -46,7 +46,7 @@
     "\n",
     "dets = [det]  # just one in this case, but it could be more than one\n",
     "\n",
-    "RE(scan(dets, motor, -1, 1, 10))"
+    "run_engine(scan(dets, motor, -1, 1, 10))"
    ]
   }
  ],