mx-bluesky 1.4.6__py3-none-any.whl → 1.4.8__py3-none-any.whl

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/log.py

@@ -66,14 +66,15 @@ def do_default_logging_setup(
     """Configures dodal logger so that separate debug and info log files are created,
     info logs are sent to Graylog, info logs are streamed to sys.sterr, and logs from ophyd
     and bluesky and ophyd-async are optionally included."""
-
+    logging_path, debug_logging_path = _get_logging_dirs()
     handlers = set_up_all_logging_handlers(
         dodal_logger,
-        _get_logging_dir(),
+        logging_path,
         file_name,
         dev_mode,
         ERROR_LOG_BUFFER_LINES,
         graylog_port,
+        debug_logging_path,
     )
 
     if integrate_all_logs:
@@ -102,8 +103,8 @@ def flush_debug_handler() -> str:
     return handler.target.baseFilename
 
 
-def _get_logging_dir() -> Path:
-    """Get the path to write the mx_bluesky log files to.
+def _get_logging_dirs() -> tuple[Path, Path]:
+    """Get the paths to write the mx_bluesky log files to.
 
     Log location can be specified in the LOG_DIR environment variable, otherwise MX bluesky logs are written to 'dls_sw/ixx/logs/bluesky'.
     This directory will be created if it is not found
@@ -111,18 +112,20 @@ def _get_logging_dir() -> Path:
     Logs are written to ./tmp/logs/bluesky if BEAMLINE environment variable is not found
 
     Returns:
-        logging_path (Path): Path to the log file for the file handler to write to.
+        tuple[Path, Path]: Paths to the standard log file and to the debug log file, for the file handlers to write to
     """
 
     logging_str = environ.get("LOG_DIR")
+    beamline = environ.get("BEAMLINE")
     if logging_str:
         logging_path = Path(logging_str)
+        debug_logging_path = logging_path
+    elif beamline:
+        logging_path = Path(f"/dls_sw/{beamline}/logs/bluesky/")
+        debug_logging_path = Path(f"/dls/tmp/{beamline}/logs/bluesky/")
     else:
-        beamline = environ.get("BEAMLINE")
-        logging_path = (
-            Path(f"/dls_sw/{beamline}/logs/bluesky/")
-            if beamline
-            else Path("/tmp/logs/bluesky")
-        )
+        logging_path = Path("/tmp/logs/bluesky")
+        debug_logging_path = logging_path
     Path.mkdir(logging_path, exist_ok=True, parents=True)
-    return logging_path
+    Path.mkdir(debug_logging_path, exist_ok=True, parents=True)
+    return logging_path, debug_logging_path

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,
 )
@@ -39,6 +36,7 @@ from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     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
@@ -84,18 +82,15 @@ class BlueskyRunner:
         self,
         RE: RunEngine,
         context: BlueskyContext,
-        skip_startup_connection=False,
     ) -> None:
         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...")
@@ -105,12 +100,6 @@ class BlueskyRunner:
         if VERBOSE_EVENT_LOGGING:
             RE.subscribe(VerbosePlanExecutionLoggingCallback())
 
-        self.skip_startup_connection = skip_startup_connection
-        if not self.skip_startup_connection:
-            LOGGER.info("Initialising dodal devices...")
-            for plan_name in PLAN_REGISTRY:
-                PLAN_REGISTRY[plan_name]["setup"](context)
-
     def start(
         self,
         experiment: Callable,
@@ -175,10 +164,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:
@@ -212,6 +198,7 @@ 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:
@@ -284,15 +271,11 @@ class FlushLogs(Resource):
 def create_app(
     test_config=None,
     RE: RunEngine = RunEngine({}),
-    skip_startup_connection: bool = False,
 ) -> tuple[Flask, BlueskyRunner]:
-    context = setup_context(
-        wait_for_connection=not skip_startup_connection,
-    )
+    context = setup_context()
     runner = BlueskyRunner(
         RE,
         context=context,
-        skip_startup_connection=skip_startup_connection,
     )
     app = Flask(__name__)
     if test_config:
@@ -322,9 +305,7 @@ def create_targets():
         CONST.LOG_FILE_NAME, CONST.GRAYLOG_PORT, dev_mode=args.dev_mode
     )
     LOGGER.info(f"Hyperion launched with args:{argv}")
-    app, runner = create_app(
-        skip_startup_connection=args.skip_startup_connection,
-    )
+    app, runner = create_app()
     return app, runner, hyperion_port, args.dev_mode
 
 

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/dcm_pitch_roll_mirror_adjuster.py

@@ -6,7 +6,7 @@ from dodal.devices.focusing_mirror import (
     MirrorStripe,
     MirrorVoltages,
 )
-from dodal.devices.undulator_dcm import UndulatorDCM
+from dodal.devices.i03.undulator_dcm import UndulatorDCM
 from dodal.devices.util.adjuster_plans import lookup_table_adjuster
 from dodal.devices.util.lookup_tables import (
     linear_interpolation_lut,
@@ -102,7 +102,7 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
     dcm = undulator_dcm.dcm_ref()
     LOGGER.info(f"Adjusting DCM and VFM for {energy_kev} keV")
     d_spacing_a: float = yield from bps.rd(
-        undulator_dcm.dcm_ref().crystal_metadata_d_spacing
+        undulator_dcm.dcm_ref().crystal_metadata_d_spacing_a
     )
     bragg_deg = energy_to_bragg_angle(energy_kev, d_spacing_a)
     LOGGER.info(f"Target Bragg angle = {bragg_deg} degrees")
@@ -110,7 +110,7 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
         linear_interpolation_lut(
             *parse_lookup_table(undulator_dcm.pitch_energy_table_path)
         ),
-        dcm.pitch_in_mrad,
+        dcm.xtal_1.pitch_in_mrad,
         bragg_deg,
     )
     yield from dcm_pitch_adjuster(DCM_GROUP)
@@ -122,7 +122,7 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
         linear_interpolation_lut(
             *parse_lookup_table(undulator_dcm.roll_energy_table_path)
         ),
-        dcm.roll_in_mrad,
+        dcm.xtal_1.roll_in_mrad,
         bragg_deg,
     )
     yield from dcm_roll_adjuster(DCM_GROUP)

mx_bluesky/hyperion/device_setup_plans/setup_panda.py

@@ -1,10 +1,12 @@
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
+from typing import cast
 
 import bluesky.plan_stubs as bps
 from bluesky.utils import MsgGenerator
 from dodal.common.beamlines.beamline_utils import get_path_provider
+from dodal.common.types import UpdatingPathProvider
 from dodal.devices.fast_grid_scan import PandAGridScanParams
 from dodal.devices.smargon import Smargon
 from ophyd_async.fastcs.panda import (
@@ -222,6 +224,8 @@ def set_panda_directory(panda_directory: Path) -> MsgGenerator:
     suffix = datetime.now().strftime("_%Y%m%d%H%M%S")
 
     async def set_panda_dir():
-        await get_path_provider().update(directory=panda_directory, suffix=suffix)
+        await cast(UpdatingPathProvider, get_path_provider()).update(
+            directory=panda_directory, suffix=suffix
+        )
 
     yield from bps.wait_for([set_panda_dir])

mx_bluesky/hyperion/device_setup_plans/setup_zebra.py

@@ -1,8 +1,4 @@
-from collections.abc import Callable
-from functools import wraps
-
 import bluesky.plan_stubs as bps
-import bluesky.preprocessors as bpp
 from bluesky.utils import MsgGenerator
 from dodal.devices.zebra.zebra import (
     ArmDemand,
@@ -21,31 +17,6 @@ from mx_bluesky.common.utils.log import LOGGER
 ZEBRA_STATUS_TIMEOUT = 30
 
 
-def bluesky_retry(func: Callable):
-    """Decorator that will retry the decorated plan if it fails.
-
-    Use this with care as it knows nothing about the state of the world when things fail.
-    If it is possible that your plan fails when the beamline is in a transient state that
-    the plan could not act on do not use this decorator without doing some more intelligent
-    clean up.
-
-    You should avoid using this decorator often in general production as it hides errors,
-    instead it should be used only for debugging these underlying errors.
-    """
-
-    @wraps(func)
-    def newfunc(*args, **kwargs):
-        def log_and_retry(exception):
-            LOGGER.error(f"Function {func.__name__} failed with {exception}, retrying")
-            yield from func(*args, **kwargs)
-
-        yield from bpp.contingency_wrapper(
-            func(*args, **kwargs), except_plan=log_and_retry, auto_raise=False
-        )
-
-    return newfunc
-
-
 def arm_zebra(zebra: Zebra):
     yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)
 
@@ -105,7 +76,6 @@ def configure_zebra_and_shutter_for_auto_shutter(
     yield from set_shutter_auto_input(zebra, input, group=group)
 
 
-@bluesky_retry
 def setup_zebra_for_rotation(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,
@@ -185,7 +155,6 @@ def setup_zebra_for_rotation(
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
 
 
-@bluesky_retry
 def setup_zebra_for_gridscan(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,
@@ -215,7 +184,6 @@ def setup_zebra_for_gridscan(
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
 
 
-@bluesky_retry
 def tidy_up_zebra_after_gridscan(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,
@@ -236,7 +204,6 @@ def tidy_up_zebra_after_gridscan(
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
 
 
-@bluesky_retry
 def setup_zebra_for_panda_flyscan(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -3,16 +3,16 @@ from collections.abc import Generator
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import Msg
-from dodal.devices.dcm import DCM
 from dodal.devices.detector import (
     DetectorParams,
 )
 from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
 from dodal.devices.eiger import EigerDetector
-from dodal.devices.i03.beamstop import Beamstop
+from dodal.devices.i03 import Beamstop
+from dodal.devices.i03.dcm import DCM
 
-from mx_bluesky.hyperion.device_setup_plans.check_beamstop import check_beamstop
-from mx_bluesky.hyperion.device_setup_plans.position_detector import (
+from mx_bluesky.common.device_setup_plans.check_beamstop import check_beamstop
+from mx_bluesky.common.device_setup_plans.position_detector import (
     set_detector_z_position,
     set_shutter,
 )

mx_bluesky/hyperion/experiment_plans/__init__.py

@@ -3,9 +3,6 @@
 The __all__ list in here are the plans that are externally available from outside Hyperion.
 """
 
-from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
-    flyscan_xray_centre,
-)
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     grid_detect_then_xray_centre,
 )
@@ -15,20 +12,13 @@ from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
 from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan import (
     pin_tip_centre_then_xray_centre,
 )
-from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
-    robot_load_then_centre,
-)
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
     multi_rotation_scan,
-    rotation_scan,
 )
 
 __all__ = [
-    "flyscan_xray_centre",
     "grid_detect_then_xray_centre",
-    "rotation_scan",
     "pin_tip_centre_then_xray_centre",
     "multi_rotation_scan",
-    "robot_load_then_centre",
     "load_centre_collect_full",
 ]

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -3,13 +3,11 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import TypedDict
 
-import mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan as flyscan_xray_centre_plan
 import mx_bluesky.hyperion.experiment_plans.rotation_scan_plan as rotation_scan_plan
 from mx_bluesky.hyperion.experiment_plans import (
     grid_detect_then_xray_centre_plan,
     load_centre_collect_full_plan,
     pin_centre_then_xray_centre_plan,
-    robot_load_then_centre_plan,
 )
 from mx_bluesky.hyperion.parameters.gridscan import (
     GridScanWithEdgeDetect,
@@ -17,7 +15,6 @@ from mx_bluesky.hyperion.parameters.gridscan import (
     PinTipCentreThenXrayCentre,
 )
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
-from mx_bluesky.hyperion.parameters.robot_load import RobotLoadThenCentre
 from mx_bluesky.hyperion.parameters.rotation import MultiRotationScan, RotationScan
 
 
@@ -38,31 +35,18 @@ class ExperimentRegistryEntry(TypedDict):
         | MultiRotationScan
         | PinTipCentreThenXrayCentre
         | LoadCentreCollect
-        | RobotLoadThenCentre
     ]
 
 
 PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
-    "flyscan_xray_centre": {
-        "setup": flyscan_xray_centre_plan.create_devices,
-        "param_type": HyperionSpecifiedThreeDGridScan,
-    },
     "grid_detect_then_xray_centre": {
         "setup": grid_detect_then_xray_centre_plan.create_devices,
         "param_type": GridScanWithEdgeDetect,
     },
-    "rotation_scan": {
-        "setup": rotation_scan_plan.create_devices,
-        "param_type": RotationScan,
-    },
     "pin_tip_centre_then_xray_centre": {
         "setup": pin_centre_then_xray_centre_plan.create_devices,
         "param_type": PinTipCentreThenXrayCentre,
     },
-    "robot_load_then_centre": {
-        "setup": robot_load_then_centre_plan.create_devices,
-        "param_type": RobotLoadThenCentre,
-    },
     "multi_rotation_scan": {
         "setup": rotation_scan_plan.create_devices,
         "param_type": MultiRotationScan,