mx-bluesky 1.4.5__py3-none-any.whl → 1.4.7__py3-none-any.whl

mx_bluesky/common/external_interaction/ispyb/ispyb_store.py

@@ -77,7 +77,7 @@ class StoreInIspyb:
         scan_data_infos,
     ) -> IspybIds:
         with ispyb.open(self.ISPYB_CONFIG_PATH) as conn:
-            assert conn is not None, "Failed to connect to ISPyB"
+            assert conn, "Failed to connect to ISPyB"
             if data_collection_group_info:
                 ispyb_ids.data_collection_group_id = (
                     self._store_data_collection_group_table(
@@ -152,6 +152,19 @@ class StoreInIspyb:
                 data_collection_id, comment, delimiter
             )
 
+    def update_data_collection_group_table(
+        self,
+        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,
+            )
+
     def _update_scan_with_end_time_and_status(
         self,
         end_time: str,
@@ -206,9 +219,16 @@ class StoreInIspyb:
     def _store_data_collection_table(
         self, conn, data_collection_id, data_collection_info
     ):
+        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)
 
     def _store_single_scan_data(

mx_bluesky/common/external_interaction/nexus/nexus_utils.py

@@ -144,7 +144,7 @@ def create_detector_parameters(detector_params: DetectorParams) -> Detector:
         list(
             detector_params.get_beam_position_pixels(detector_params.detector_distance)
         ),
-        detector_params.exposure_time,
+        detector_params.exposure_time_s,
         [(-1.0, 0.0, 0.0), (0.0, -1.0, 0.0)],
     )
 

mx_bluesky/common/parameters/constants.py

@@ -58,6 +58,8 @@ class PlanNameConstants:
     ROTATION_OUTER = "rotation_scan_with_cleanup"
     ROTATION_MAIN = "rotation_scan_main"
     FLYSCAN_RESULTS = "xray_centre_results"
+    SET_ENERGY = "set_energy"
+    UNNAMED_RUN = "unnamed_run"
 
 
 @dataclass(frozen=True)
@@ -130,7 +132,7 @@ class PlanGroupCheckpointConstants:
 class DeviceSettingsConstants:
     PANDA_FLYSCAN_SETTINGS_FILENAME = "panda-gridscan"
     PANDA_FLYSCAN_SETTINGS_DIR = os.path.abspath(
-        f"{ROOT_DIR}/hyperion/resources/panda/{PANDA_FLYSCAN_SETTINGS_FILENAME}"
+        f"{ROOT_DIR}/hyperion/resources/panda/"
     )
 
 

mx_bluesky/common/parameters/gridscan.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 from dodal.devices.aperturescatterguard import ApertureValue
+from dodal.devices.detector.det_dim_constants import EIGER2_X_9M_SIZE, EIGER2_X_16M_SIZE
+from dodal.devices.detector.detector import DetectorParams
 from dodal.devices.fast_grid_scan import (
     ZebraGridScanParams,
 )
+from dodal.utils import get_beamline_name
 from pydantic import Field, PrivateAttr
 from scanspec.core import Path as ScanPath
 from scanspec.specs import Line, Static
@@ -18,11 +21,12 @@ from mx_bluesky.common.parameters.components import (
     XyzStarts,
 )
 from mx_bluesky.common.parameters.constants import (
+    DetectorParamConstants,
     GridscanParamConstants,
     HardwareConstants,
 )
 
-"""Parameter models in this file are abstract. They should be inherited by a top-level model"""
+DETECTOR_SIZE_PER_BEAMLINE = {"i02-1": EIGER2_X_9M_SIZE, "dev": EIGER2_X_16M_SIZE}
 
 
 class GridCommon(
@@ -146,3 +150,34 @@ class SpecifiedThreeDGridScan(
     @property
     def num_images(self) -> int:
         return len(self.scan_points["sam_x"])
+
+    @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"
+        )
+        return DetectorParams(
+            detector_size_constants=DETECTOR_SIZE_PER_BEAMLINE[
+                get_beamline_name("dev")
+            ],
+            expected_energy_ev=self.demand_energy_ev,
+            exposure_time_s=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,
+        )

mx_bluesky/common/plans/do_fgs.py

@@ -14,12 +14,10 @@ from dodal.log import LOGGER
 from dodal.plan_stubs.check_topup import check_topup_and_wait_if_necessary
 from scanspec.core import AxesPoints, Axis
 
-from mx_bluesky.common.device_setup_plans.read_hardware_for_setup import (
-    read_hardware_for_zocalo,
-)
 from mx_bluesky.common.parameters.constants import (
     PlanNameConstants,
 )
+from mx_bluesky.common.plans.read_hardware import read_hardware_for_zocalo
 from mx_bluesky.common.utils.tracing import TRACER
 
 
@@ -30,7 +28,7 @@ def _wait_for_zocalo_to_stage_then_do_fgs(
     during_collection_plan: Callable[[], MsgGenerator] | None = None,
 ):
     expected_images = yield from bps.rd(grid_scan_device.expected_images)
-    exposure_sec_per_image = yield from bps.rd(detector.cam.acquire_time)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    exposure_sec_per_image = yield from bps.rd(detector.cam.acquire_time)  # type: ignore # Fix types in ophyd-async (https://github.com/DiamondLightSource/mx-bluesky/issues/855)
     LOGGER.info("waiting for topup if necessary...")
     yield from check_topup_and_wait_if_necessary(
         synchrotron,
@@ -101,8 +99,8 @@ def kickoff_and_complete_gridscan(
         }
     )
     @bpp.contingency_decorator(
-        except_plan=lambda e: (yield from bps.stop(detector)),  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        else_plan=lambda: (yield from bps.unstage(detector)),  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        except_plan=lambda e: (yield from bps.stop(detector)),  # type: ignore # Fix types in ophyd-async (https://github.com/DiamondLightSource/mx-bluesky/issues/855)
+        else_plan=lambda: (yield from bps.unstage(detector)),
     )
     def _decorated_do_fgs():
         yield from _wait_for_zocalo_to_stage_then_do_fgs(

mx_bluesky/common/plans/read_hardware.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import bluesky.plan_stubs as bps
+from bluesky.protocols import Readable
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.dcm import DCM
+from dodal.devices.eiger import EigerDetector
+from dodal.devices.flux import Flux
+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 mx_bluesky.common.parameters.constants import (
+    DocDescriptorNames,
+)
+from mx_bluesky.common.utils.log import LOGGER
+
+
+def read_hardware_plan(
+    signals: list[Readable],
+    event_name: str,
+):
+    LOGGER.info(f"Reading status of beamline for event, {event_name}")
+    yield from bps.create(name=event_name)
+    for signal in signals:
+        yield from bps.read(signal)
+    yield from bps.save()
+
+
+def read_hardware_for_zocalo(detector: EigerDetector):
+    """ "
+    If the RunEngine is subscribed to the ZocaloCallback, this plan will also trigger zocalo.
+    """
+    yield from read_hardware_plan(
+        [detector.odin.file_writer.id],  # type: ignore
+        DocDescriptorNames.ZOCALO_HW_READ,
+    )
+
+
+def standard_read_hardware_pre_collection(
+    undulator: Undulator,
+    synchrotron: Synchrotron,
+    s4_slit_gaps: S4SlitGaps,
+    dcm: DCM,
+    smargon: Smargon,
+):
+    LOGGER.info("Reading status of beamline for callbacks, pre collection.")
+    signals_to_read_pre_flyscan = [
+        undulator.current_gap,
+        synchrotron.synchrotron_mode,
+        s4_slit_gaps,
+        smargon,
+        dcm.energy_in_kev,
+    ]
+    yield from read_hardware_plan(
+        signals_to_read_pre_flyscan, DocDescriptorNames.HARDWARE_READ_PRE
+    )
+
+
+def standard_read_hardware_during_collection(
+    aperture_scatterguard: ApertureScatterguard,
+    attenuator: BinaryFilterAttenuator,
+    flux: Flux,
+    dcm: DCM,
+    detector: EigerDetector,
+):
+    signals_to_read_during_collection = [
+        aperture_scatterguard,
+        attenuator.actual_transmission,
+        flux.flux_reading,
+        dcm.energy_in_kev,
+        detector.bit_depth,
+    ]
+    yield from read_hardware_plan(
+        signals_to_read_during_collection, DocDescriptorNames.HARDWARE_READ_DURING
+    )

mx_bluesky/common/plans/write_sample_status.py

@@ -0,0 +1,46 @@
+from enum import StrEnum
+
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+
+from mx_bluesky.common.external_interaction.callbacks.sample_handling.sample_handling_callback import (
+    SampleHandlingCallback,
+)
+from mx_bluesky.common.utils.exceptions import SampleException
+
+
+class SampleStatusExceptionType(StrEnum):
+    BEAMLINE = "Beamline"
+    SAMPLE = "Sample"
+
+
+@bpp.subs_decorator(SampleHandlingCallback())
+def deposit_sample_error(exception_type: SampleStatusExceptionType, sample_id: int):
+    @bpp.run_decorator(
+        md={
+            "metadata": {"sample_id": sample_id},
+            "activate_callbacks": ["SampleHandlingCallback"],
+        }
+    )
+    def _inner():
+        yield from bps.null()
+        if exception_type == SampleStatusExceptionType.BEAMLINE:
+            raise AssertionError()
+        elif exception_type == SampleStatusExceptionType.SAMPLE:
+            raise SampleException
+
+    yield from _inner()
+
+
+@bpp.subs_decorator(SampleHandlingCallback(record_loaded_on_success=True))
+def deposit_loaded_sample(sample_id: int):
+    @bpp.run_decorator(
+        md={
+            "metadata": {"sample_id": sample_id},
+            "activate_callbacks": ["SampleHandlingCallback"],
+        }
+    )
+    def _inner():
+        yield from bps.null()
+
+    yield from _inner()

mx_bluesky/common/preprocessors/preprocessors.py

@@ -0,0 +1,105 @@
+from bluesky import preprocessors as bpp
+from bluesky.preprocessors import plan_mutator
+from bluesky.utils import Msg, MsgGenerator, make_decorator
+
+from mx_bluesky.common.device_setup_plans.xbpm_feedback import (
+    check_and_pause_feedback,
+    unpause_xbpm_feedback_and_set_transmission_to_1,
+)
+from mx_bluesky.common.parameters.constants import PlanNameConstants
+from mx_bluesky.common.protocols.protocols import (
+    XBPMPauseDevices,
+)
+
+
+def transmission_and_xbpm_feedback_for_collection_wrapper(
+    plan: MsgGenerator,
+    devices: XBPMPauseDevices,
+    desired_transmission_fraction: float,
+    run_key_to_wrap: PlanNameConstants | None = None,
+):
+    """
+    Sets the transmission for the data collection, ensuring the xbpm feedback is valid, then resets it immediately after
+    the run has finished.
+
+    This wrapper should be attached to the entry point of any beamline-specific plan that may disrupt the XBPM feedback,
+    such as a data collection or an x-ray center grid scan.
+    This wrapper will do nothing if no runs are seen.
+
+    XBPM feedback isn't reliable during collections due to:
+     * Objects (e.g. attenuator) crossing the beam can cause large (incorrect) feedback movements
+     * Lower transmissions/higher energies are less reliable for the xbpm
+
+    So we need to keep the transmission at 100% and the feedback on when not collecting
+    and then turn it off and set the correct transmission for collection. The feedback
+    mostly accounts for slow thermal drift so it is safe to assume that the beam is
+    stable during a collection.
+
+    Args:
+        plan: The plan performing the data collection.
+        devices (XBPMPauseDevices): Composite device including The XBPM device that is responsible for keeping
+                                                        the beam in position, and attenuator
+        desired_transmission_fraction (float): The desired transmission for the collection
+        run_key_to_wrap: (str | None): Pausing XBPM and setting transmission is inserted after the 'open_run' message is seen with
+        the matching run key, and unpausing and resetting transmission is inserted after the corresponding 'close_run' message is
+        seen. If not specified, instead wrap the first run encountered.
+    """
+
+    _wrapped_run_name: None | str = None
+
+    def head(msg: Msg):
+        yield from check_and_pause_feedback(
+            devices.xbpm_feedback,
+            devices.attenuator,
+            desired_transmission_fraction,
+        )
+
+        # Allow 'open_run' message to pass through
+        yield msg
+
+    def tail():
+        yield from unpause_xbpm_feedback_and_set_transmission_to_1(
+            devices.xbpm_feedback, devices.attenuator
+        )
+
+    def insert_plans(msg: Msg):
+        # Wrap the specified run, or, if none specified, wrap the first run encountered
+        nonlocal _wrapped_run_name
+
+        match msg.command:
+            case "open_run":
+                # If we specified a run key, did we encounter it
+                # If we didn't specify, then insert the plans and track the name of the run
+                if (
+                    not (run_key_to_wrap or _wrapped_run_name)
+                    or run_key_to_wrap is msg.run
+                ):
+                    _wrapped_run_name = msg.run if msg.run else "unnamed_run"
+                    return head(msg), None
+            case "close_run":
+                # Check if the run tracked from above was closed
+                # An exception is raised in the RunEngine if two unnamed runs are opened
+                # at the same time, so we are safe from unpausing on the wrong run
+                if (_wrapped_run_name == "unnamed_run" and not msg.run) or (
+                    msg.run and _wrapped_run_name and _wrapped_run_name is msg.run
+                ):
+                    return None, tail()
+
+        return None, None
+
+    # Contingency wrapper can cause unpausing to occur on exception and again on close_run.
+    # Not needed after https://github.com/bluesky/bluesky/issues/1891
+    return (
+        yield from bpp.contingency_wrapper(
+            plan_mutator(plan, insert_plans),
+            except_plan=lambda _: unpause_xbpm_feedback_and_set_transmission_to_1(
+                devices.xbpm_feedback,
+                devices.attenuator,
+            ),
+        )
+    )
+
+
+transmission_and_xbpm_feedback_for_collection_decorator = make_decorator(
+    transmission_and_xbpm_feedback_for_collection_wrapper
+)

mx_bluesky/common/protocols/protocols.py

@@ -0,0 +1,10 @@
+from typing import Protocol, runtime_checkable
+
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.xbpm_feedback import XBPMFeedback
+
+
+@runtime_checkable
+class XBPMPauseDevices(Protocol):
+    xbpm_feedback: XBPMFeedback
+    attenuator: BinaryFilterAttenuator

mx_bluesky/common/utils/context.py

@@ -0,0 +1,68 @@
+import dataclasses
+from typing import Any, ClassVar, Protocol, TypeVar, get_type_hints
+
+from blueapi.core import BlueskyContext
+from blueapi.core.bluesky_types import Device
+
+from mx_bluesky.common.utils.log import LOGGER
+
+T = TypeVar("T", bound=Device)
+
+
+class _IsDataclass(Protocol):
+    """Protocol followed by any dataclass"""
+
+    __dataclass_fields__: ClassVar[dict]
+
+
+DT = TypeVar("DT", bound=_IsDataclass)
+
+
+def find_device_in_context(
+    context: BlueskyContext,
+    name: str,
+    # Typing in here is wrong (see https://github.com/microsoft/pyright/issues/7228#issuecomment-1934500232)
+    # but this whole thing will go away when we do https://github.com/DiamondLightSource/hyperion/issues/868
+    expected_type: type[T] = Device,  # type: ignore
+) -> T:
+    LOGGER.debug(f"Looking for device {name} of type {expected_type} in context")
+
+    device = context.find_device(name)
+    if device is None:
+        raise ValueError(
+            f"Cannot find device named '{name}' in bluesky context {context.devices}."
+        )
+
+    if not isinstance(device, expected_type):
+        raise ValueError(
+            f"Found device named '{name}' and expected it to be a '{expected_type}' but it was a '{device.__class__.__name__}'"
+        )
+
+    LOGGER.debug(f"Found matching device {device}")
+    return device
+
+
+def device_composite_from_context(context: BlueskyContext, dc: type[DT]) -> DT:
+    """
+    Initializes all of the devices referenced in a given dataclass from a provided
+    context, checking that the types of devices returned by the context are compatible
+    with the type annotations of the dataclass.
+
+    Note that if the context was not created with `wait_for_connection=True` devices may
+    still be unconnected.
+    """
+    LOGGER.debug(
+        f"Attempting to initialize devices referenced in dataclass {dc} from blueapi context"
+    )
+
+    devices: dict[str, Any] = {}
+    dc_type_hints: dict[str, Any] = get_type_hints(dc)
+
+    for field in dataclasses.fields(dc):
+        device = find_device_in_context(
+            context, field.name, expected_type=dc_type_hints.get(field.name, Device)
+        )
+
+        devices[field.name] = device
+
+    return dc(**devices)

mx_bluesky/{hyperion/experiment_plans/common → common}/xrc_result.py

@@ -5,6 +5,8 @@ from collections.abc import Callable, Sequence
 from functools import partial
 
 import numpy as np
+from bluesky.callbacks import CallbackBase
+from event_model import RunStart
 
 from mx_bluesky.common.parameters.components import (
     MultiXtalSelection,
@@ -12,6 +14,20 @@ from mx_bluesky.common.parameters.components import (
 )
 
 
+class XRayCentreEventHandler(CallbackBase):
+    def __init__(self):
+        super().__init__()
+        self.xray_centre_results: Sequence[XRayCentreResult] | None = None
+
+    def start(self, doc: RunStart) -> RunStart | None:
+        if "xray_centre_results" in doc:
+            self.xray_centre_results = [
+                XRayCentreResult(**result_dict)
+                for result_dict in doc["xray_centre_results"]  # type: ignore
+            ]
+        return doc
+
+
 @dataclasses.dataclass
 class XRayCentreResult:
     """

mx_bluesky/hyperion/__main__.py

@@ -16,9 +16,6 @@ from flask import Flask, request
 from flask_restful import Api, Resource
 from pydantic.dataclasses import dataclass
 
-from mx_bluesky.common.external_interaction.callbacks.common.aperture_change_callback import (
-    ApertureChangeCallback,
-)
 from mx_bluesky.common.external_interaction.callbacks.common.log_uid_tag_callback import (
     LogUidTaggingCallback,
 )
@@ -38,6 +35,10 @@ from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     PLAN_REGISTRY,
     PlanNotFound,
 )
+from mx_bluesky.hyperion.external_interaction.agamemnon import (
+    compare_params,
+    update_params_from_agamemnon,
+)
 from mx_bluesky.hyperion.parameters.cli import parse_cli_args
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.utils.context import setup_context
@@ -86,13 +87,11 @@ class BlueskyRunner:
         self.command_queue: Queue[Command] = Queue()
         self.current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
         self.last_run_aborted: bool = False
-        self.aperture_change_callback = ApertureChangeCallback()
         self.logging_uid_tag_callback = LogUidTaggingCallback()
         self.context: BlueskyContext
 
         self.RE = RE
         self.context = context
-        RE.subscribe(self.aperture_change_callback)
         RE.subscribe(self.logging_uid_tag_callback)
 
         LOGGER.info("Connecting to external callback ZMQ proxy...")
@@ -172,10 +171,7 @@ class BlueskyRunner:
                     with TRACER.start_span("do_run"):
                         self.RE(command.experiment(command.devices, command.parameters))
 
-                    self.current_status = StatusAndMessage(
-                        Status.IDLE,
-                        self.aperture_change_callback.last_selected_aperture,
-                    )
+                    self.current_status = StatusAndMessage(Status.IDLE)
 
                     self.last_run_aborted = False
                 except WarningException as exception:
@@ -208,6 +204,8 @@ def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions)
         )
     try:
         parameters = experiment_internal_param_type(**json.loads(request.data))
+        parameters = update_params_from_agamemnon(parameters)
+        compare_params(parameters)
         if parameters.model_extra:
             raise ValueError(f"Extra fields not allowed {parameters.model_extra}")
     except Exception as e:

mx_bluesky/hyperion/baton_handler.py

@@ -0,0 +1,84 @@
+from bluesky import plan_stubs as bps
+from bluesky import preprocessors as bpp
+from dodal.devices.baton import Baton
+
+from mx_bluesky.common.utils.exceptions import WarningException
+from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
+    LoadCentreCollectComposite,
+    load_centre_collect_full,
+)
+from mx_bluesky.hyperion.external_interaction.agamemnon import (
+    create_parameters_from_agamemnon,
+)
+from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+
+HYPERION_USER = "Hyperion"
+NO_USER = "None"
+
+
+def wait_for_hyperion_requested(baton: Baton):
+    SLEEP_PER_CHECK = 0.1
+    while True:
+        requested_user = yield from bps.rd(baton.requested_user)
+        if requested_user == HYPERION_USER:
+            break
+        yield from bps.sleep(SLEEP_PER_CHECK)
+
+
+def ignore_sample_errors(exception: Exception):
+    yield from bps.null()
+    # For sample errors we want to continue the loop
+    if not isinstance(exception, WarningException):
+        raise exception
+
+
+def main_hyperion_loop(baton: Baton, composite: LoadCentreCollectComposite):
+    requested_user = yield from bps.rd(baton.requested_user)
+    while requested_user == HYPERION_USER:
+
+        def inner_loop():
+            parameters: LoadCentreCollect | None = create_parameters_from_agamemnon()  # type: ignore # not complete until https://github.com/DiamondLightSource/mx-bluesky/issues/773
+            if parameters:
+                yield from load_centre_collect_full(composite, parameters)
+            else:
+                yield from bps.mv(baton.requested_user, NO_USER)
+
+        yield from bpp.contingency_wrapper(
+            inner_loop(), except_plan=ignore_sample_errors, auto_raise=False
+        )
+        requested_user = yield from bps.rd(baton.requested_user)
+
+
+def move_to_default_state():
+    # To be filled in in https://github.com/DiamondLightSource/mx-bluesky/issues/396
+    yield from bps.null()
+
+
+def run_udc_when_requested(baton: Baton, composite: LoadCentreCollectComposite):
+    """This will wait for the baton to be handed to hyperion and then run through the
+    UDC queue from agamemnon until:
+      1. There are no more instructions from agamemnon
+      2. There is an error on the beamline
+      3. The baton is requested by another party
+
+    In the case of 1. or 2. hyperion will immediately release the baton. In the case of
+    3. the baton will be released after the next collection has finished."""
+
+    yield from wait_for_hyperion_requested(baton)
+    yield from bps.abs_set(baton.current_user, HYPERION_USER)
+
+    def default_state_then_collect():
+        yield from move_to_default_state()
+        yield from main_hyperion_loop(baton, composite)
+
+    def release_baton():
+        # If hyperion has given up the baton itself we need to also release requested
+        # user so that hyperion doesn't think we're requested again
+        requested_user = yield from bps.rd(baton.requested_user)
+        if requested_user == HYPERION_USER:
+            yield from bps.abs_set(baton.requested_user, NO_USER)
+        yield from bps.abs_set(baton.current_user, NO_USER)
+
+    yield from bpp.contingency_wrapper(
+        default_state_then_collect(), final_plan=release_baton
+    )

mx_bluesky/hyperion/device_setup_plans/setup_oav.py

@@ -55,14 +55,14 @@ def setup_pin_tip_detection_params(
 
 
 def setup_general_oav_params(oav: OAV, parameters: OAVParameters):
-    yield from set_using_group(oav.cam.color_mode, ColorMode.RGB1)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-    yield from set_using_group(oav.cam.acquire_period, parameters.acquire_period)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-    yield from set_using_group(oav.cam.acquire_time, parameters.exposure)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-    yield from set_using_group(oav.cam.gain, parameters.gain)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from set_using_group(oav.cam.color_mode, ColorMode.RGB1)
+    yield from set_using_group(oav.cam.acquire_period, parameters.acquire_period)
+    yield from set_using_group(oav.cam.acquire_time, parameters.exposure)
+    yield from set_using_group(oav.cam.gain, parameters.gain)
 
     zoom_level_str = f"{float(parameters.zoom)}x"
     yield from bps.abs_set(
-        oav.zoom_controller,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        oav.zoom_controller,
         zoom_level_str,
         wait=True,
     )