mx-bluesky 1.5.5__tar.gz → 1.5.6__tar.gz

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mx-bluesky
-Version: 1.5.5
+Version: 1.5.6
 Summary: Bluesky tools for MX Beamlines at DLS
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License
@@ -241,7 +241,7 @@ Requires-Dist: blueapi>=0.15.0
 Requires-Dist: ophyd>=1.10.5
 Requires-Dist: ophyd-async>=0.10.0a2
 Requires-Dist: bluesky>=1.13.1
-Requires-Dist: dls-dodal==1.57.0
+Requires-Dist: dls-dodal==1.58.0
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: build; extra == "dev"

mx_bluesky-1.5.6/docs/developer/murko-integration/explanations/DrawioImages.rst

@@ -0,0 +1,13 @@
+Draw.io Images
+--------------
+
+When working with diagrams created using Draw.io, it's important to ensure that the images retain their embedded metadata. This metadata allows the diagrams to be re-uploaded to Draw.io later for editing.
+
+To preserve this metadata:
+
+- When exporting from Draw.io, use the "File > Export As > PNG (with embedded XML)" or SVG (with embedded content) option.
+- Make sure the "Include a copy of my diagram" or similar checkbox is selected during export.
+
+This ensures that the image isn't just a flat graphic—it includes the necessary data for Draw.io to reconstruct and edit the diagram later.
+
+Tip: There is a chance of losing the metadata though if not handled properly. Sharing the image through Slack for example will delete the metadata associated with the image. Instead, use something like e-mail.

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/docs/developer/murko-integration/explanations/architecture.rst

@@ -3,7 +3,7 @@ Murko Architecture
 
 The architecture of how Murko is integrated is still in flux but as of 07/08 the following has been tried on the beamline.
 
-.. image:: ../images/murko_setup.drawio.png
+.. image:: ../images/Murko.drawio.png
 
 The mx-bluesky code is deployed into the `beamline kubernetes cluster <https://k8s-i04.diamond.ac.uk/>`_ behind a `blueAPI <https://github.com/DiamondLightSource/blueapi>`_ REST interface. Alongside this an instance of murko is also deployed to the k8s cluster.
 

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/docs/developer/murko-integration/index.rst

@@ -16,6 +16,7 @@ Its integration at DLS, using Bluesky, is still a work in progress but this docu
             :maxdepth: 1
 
             explanations/architecture
+            explanations/DrawioImages
 
         +++
 

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/docs/user/hyperion/configuration.rst

@@ -1,6 +1,9 @@
 Configuration
 -------------
 
+Hyperion main configuration
+===========================
+
 Configuration of several properties that control Hyperion execution are available. These can be edited in the 
 ``domain.properties`` file typically found in
 
@@ -8,6 +11,8 @@ Configuration of several properties that control Hyperion execution are availabl
 
     /dls_sw/<beamline>/software/daq_configuration/domain.properties
 
+Note that making a change to these properties generally requires a restart of the GDA server.
+
 
 .. csv-table:: Configuration properties
     :widths: auto
@@ -23,3 +28,27 @@ Configuration of several properties that control Hyperion execution are availabl
     "gda.mx.hyperion.xrc.use_gpu_results", "boolean", "If true, then zocalo gridscan processing uses the GPU results"
     "gda.mx.hyperion.xrc.use_roi_mode", "boolean", "If true then ROI mode is used."
     "gda.mx.udc.hyperion.enable", "boolean",  "Enables Hyperion UDC mode."
+
+Beamline configuration/calibration files
+========================================
+
+Hyperion makes use of other beamline configuration and calibration files which are also currently stored in 
+
+::
+
+    /dls_sw/<beamline>/software/daq_configuration
+
+These are currently shared with GDA, so changes to these files will affect both applications.
+
+Config Server
+=============
+
+If the `Config Server`_ is deployed and running, Hyperion is configured to use it in preference to reading the 
+``domain.properties`` file directly. However in the event of the config server being unavailable Hyperion will fall
+back to reading it from the filesystem.
+
+Note that currently the rest of the configuration files are not read from the config server, but the intention is that 
+ultimately it will be the source of all configuration and the remainder of the files in ``daq_configuration`` will be
+moved over to it.
+
+.. _Config Server: https://github.com/DiamondLightSource/daq-config-server/

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/docs/user/hyperion/index.rst

@@ -18,6 +18,23 @@ The software supports two modes of operation:
 
 The mode of operation is determined by configuration using the ``gda.mx.udc.hyperion.enable`` parameter
 
+Once Hyperion has received a request, either from GDA or directly from Agamemnon, it will do the following tasks:
+
+- Robot Load (if necessary)
+- Pin tip detection using the OAV
+- Xray Centring
+- A number of data collections, depending on the number of centres returned from Zocalo and the applied selection criteria
+
+During this it will generate the following outputs:
+
+- Snapshots on robot load, XRC and rotations
+- Data collections in ISPyB for the gridscans and rotations as well as entries for robot load/unload
+- Nexus files for each data collection
+- Alert notifications on loading a new container and on beamline error conditions when intervention is required.  
+
+For a more detailed breakdown of the operation, it may be helpful to browse the  `Code Map`_
+
+.. _Code Map: ../../developer/code-map 
 
 .. toctree::
     :caption: Topics

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/docs/user/hyperion/pvs.rst

@@ -10,3 +10,12 @@ CURRENT_USER.
 Hyperion will only start operating once REQUESTED_USER has been set to Hyperion, at which point it will set 
 CURRENT_USER. To request the baton from Hyperion, set REQUESTED_USER to some other value, when Hyperion completes the
 current action, it will relinquish CURRENT_USER.
+
+Commissioning Mode
+~~~~~~~~~~~~~~~~~~
+
+The baton device also has a COMMISSIONING PV, which when the PV is set to 1, indicates that commissioning mode is 
+enabled.
+
+Commissioning mode enables testing of Hyperion when there is no beam. Beamline scientists should ensure that the 
+COMMISSIONING PV is set to 0 before running Hyperion in production.

mx_bluesky-1.5.6/docs/user/hyperion/troubleshooting.rst

@@ -0,0 +1,137 @@
+Troubleshooting
+===============
+
+.. contents::
+
+Logging
+-------
+
+Hyperion logs to a number of different locations. The sections below describe the locations that are configured via 
+environment variables for a standard server install.
+
+Graylog
+~~~~~~~
+
+Graylog is the recommended way to view logs. It is used for more centralised logging which is also more easily 
+searched and archived. Log messages are sent to the `Hyperion graylog stream <https://graylog.diamond.ac.uk/streams/66264f5519ccca6d1c9e4e03/search>`_.
+
+
+Startup Log
+~~~~~~~~~~~
+
+When ``hyperion_restart()`` is called by GDA, it will log the initial console output to a log file. This log file 
+location is 
+controlled by the ``gda.logs.dir`` property and is typically ``/dls_sw/<beamline>/logs/bluesky``.
+
+Log files
+~~~~~~~~~
+
+By default, Hyperion logs to the filesystem.
+
+The log file location is controlled by the ``LOG_DIR`` environment value. Typically this can be found in 
+``/dls_sw/<beamline>/logs/bluesky``
+
+Debug Log
+~~~~~~~~~
+
+The standard logs files do not record all messages, only those at INFO level or higher, in order to keep storage 
+requirements to a minimum. 
+In the event of an error occurring, then trace-level logging for the most recent events (by default 5000) is flushed 
+to a separate set of log files. Due to the size of these files, they are stored separately from the main log files
+. These logs are located in ``/dls/tmp/<beamline>/logs/bluesky`` by default, or 
+otherwise as specified by the ``DEBUG_LOG_DIR`` environment variable. 
+
+Server Install
+--------------
+
+Install Location
+~~~~~~~~~~~~~~~~
+
+Hyperion is generally installed in the beamline software directory:
+
+``/dls_sw/<beamline>/software/bluesky``
+
+This directory contains versioned installation folders ``mx-bluesky_vx.y.z`` for each installed version. Within the 
+directory there is a symlink ``hyperion`` to the currently active version. This is generally a symlink to either 
+``hyperion_stable`` or ``hyperion_latest`` symlinks which then point to the latest stable and development releases 
+respectively.
+
+Switching Versions
+~~~~~~~~~~~~~~~~~~
+
+For example to switch from the development to the stable release simply:
+
+::
+
+    rm hyperion
+    ln -s hyperion_latest hyperion
+
+After this you will need to run ``hyperion_restart()`` in the GDA jython console to restart hyperion
+
+Verifying that Hyperion is running
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To verify that the correct version of Hyperion is running, you should be able to view the process on the control 
+server, ssh into the control server, the output of ``ps ax`` should be something like the following, showing which 
+deployment is currently running. You should see two processes, the main process and also the external callback process. 
+
+::
+
+    $ ps ax | grep hyperion
+    1181420 ?        Sl     2:36 /dls_sw/i03/software/bluesky/mx-bluesky_v1.5.0/mx-bluesky/.venv/bin/python /dls_sw/i03/software/bluesky/mx-bluesky_v1.5.0/mx-bluesky/.venv/bin/hyperion
+    1181422 ?        Sl     1:54 /dls_sw/i03/software/bluesky/mx-bluesky_v1.5.0/mx-bluesky/.venv/bin/python /dls_sw/i03/software/bluesky/mx-bluesky_v1.5.0/mx-bluesky/.venv/bin/hyperion-callbacks
+
+Kubernetes Install
+------------------
+
+If Hyperion is deployed on Kubernetes (currently experimental) then it can be managed from the beamline kubernetes 
+dashboard, e.g. 
+https://k8s-i03-dashboard.diamond.ac.uk
+
+In the beamline namespace there will be a deployment ``hyperion-deployment``, a ``hyperion-svc`` service and associated 
+pods, ingress etc. through which the current state may be observed / managed.
+
+Logging
+~~~~~~~
+
+On kubernetes deployments, the initial startup is sent to standard IO and is captured as part of the standard 
+kubernetes logging facility.
+
+The configured logging locations are defined in the ``values.yaml`` for the specific deployment Helm chart. 
+
+Known Issues
+------------
+
+Odin Errors when there are filesystem issues
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+https://github.com/DiamondLightSource/mx-bluesky/issues/1199
+
+On occasions where there are issues with the filesystem you may see errors similar to
+
+::
+
+    ophyd.utils.errors.UnknownStatusFailure: The status (Status(obj=EpicsSignalWithRBV
+    (read_pv='BL03I-EA-EIGER-01:OD:Capture_RBV', name='eiger_odin_file_writer_capture', parent='eiger_odin_file_writer',
+    value=0, timestamp=1754488753.208739, auto_monitor=False, string=False, write_pv='BL03I-EA-EIGER-01:OD:Capture',
+    limits=False, put_complete=False), done=True, success=False) & SubscriptionStatus(device=eiger_odin_meta_ready,
+    done=False, success=False)) has failed. To obtain more specific, helpful errors in the future, update the Device
+    to use set_exception(...) instead of _finished(success=False).
+
+hyperion_restart() sometimes times out
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sometimes hyperion_restart() will time out waiting for Hyperion to start, in the Jython console you may see the 
+following
+
+::
+
+    InteractiveConsole exception: hyperion_utils.exceptions.HyperionFailedException: Hyperion failed to start, see /dls_sw/i03/logs/bluesky/start_log.log for log
+    org.python.core.PyException: hyperion_utils.exceptions.HyperionFailedException: Hyperion failed to start, see /dls_sw/i03/logs/bluesky/start_log.log for log
+	at org.python.core.PyException.doRaise(PyException.java:239)
+	at org.python.core.Py.makeException(Py.java:1654)
+	at org.python.core.Py.makeException(Py.java:1658)
+	at org.python.core.Py.makeException(Py.java:1662)
+
+However on inspection the start log will not show any errors. Hyperion running can be verified as above `Verifying 
+that Hyperion is running`_

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/pyproject.toml

@@ -48,7 +48,7 @@ dependencies = [
     "ophyd >= 1.10.5",
     "ophyd-async >= 0.10.0a2",
     "bluesky >= 1.13.1",
-    "dls-dodal == 1.57.0",
+    "dls-dodal == 1.58.0",
 ]
 
 

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.5.5'
-__version_tuple__ = version_tuple = (1, 5, 5)
+__version__ = version = '1.5.6'
+__version_tuple__ = version_tuple = (1, 5, 6)
 
-__commit_id__ = commit_id = 'gb6ac6ef7f'
+__commit_id__ = commit_id = 'g6a9297fcb'

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/common/experiment_plans/common_flyscan_xray_centre_plan.py

@@ -9,6 +9,7 @@ import bluesky.preprocessors as bpp
 import numpy as np
 from bluesky.protocols import Readable
 from bluesky.utils import MsgGenerator
+from dodal.common.beamlines.commissioning_mode import read_commissioning_mode
 from dodal.devices.fast_grid_scan import (
     FastGridScanCommon,
 )
@@ -226,11 +227,33 @@ def _fetch_xrc_results_from_zocalo(
             for xr in filtered_results
         ]
     else:
-        LOGGER.warning("No X-ray centre received")
-        raise CrystalNotFoundException()
+        commissioning_mode = yield from read_commissioning_mode()
+        if commissioning_mode:
+            LOGGER.info("Commissioning mode enabled, returning dummy result")
+            flyscan_results = [_generate_dummy_xrc_result(parameters)]
+        else:
+            LOGGER.warning("No X-ray centre received")
+            raise CrystalNotFoundException()
     yield from _fire_xray_centre_result_event(flyscan_results)
 
 
+def _generate_dummy_xrc_result(params: SpecifiedThreeDGridScan) -> XRayCentreResult:
+    com = [params.x_steps / 2, params.y_steps / 2, params.z_steps / 2]
+    max_voxel = [round(p) for p in com]
+    return _xrc_result_in_boxes_to_result_in_mm(
+        XrcResult(
+            centre_of_mass=com,
+            max_voxel=max_voxel,
+            bounding_box=[max_voxel, [p + 1 for p in max_voxel]],
+            n_voxels=1,
+            max_count=10000,
+            total_count=100000,
+            sample_id=params.sample_id,
+        ),
+        params,
+    )
+
+
 @bpp.set_run_key_decorator(PlanNameConstants.GRIDSCAN_MAIN)
 @bpp.run_decorator(md={"subplan_name": PlanNameConstants.GRIDSCAN_MAIN})
 def run_gridscan(

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/common/parameters/components.py

@@ -231,6 +231,7 @@ class DiffractionExperimentWithSample(DiffractionExperiment, WithSample): ...
 
 class MultiXtalSelection(BaseModel):
     name: str
+    ignore_xtal_not_found: bool = False
 
 
 class TopNByMaxCountSelection(MultiXtalSelection):

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/hyperion/__main__.py

@@ -1,4 +1,5 @@
 import json
+import signal
 import threading
 from dataclasses import asdict
 from sys import argv
@@ -32,9 +33,10 @@ from mx_bluesky.hyperion.parameters.cli import (
     HyperionMode,
     parse_cli_args,
 )
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.parameters.constants import CONST, HyperionConstants
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 from mx_bluesky.hyperion.plan_runner import PlanRunner
+from mx_bluesky.hyperion.plan_runner_api import create_server_for_udc
 from mx_bluesky.hyperion.runner import (
     GDARunner,
     StatusAndMessage,
@@ -170,7 +172,7 @@ def main():
     """Main application entry point."""
     args = parse_cli_args()
     initialise_globals(args)
-    hyperion_port = 5005
+    hyperion_port = HyperionConstants.HYPERION_PORT
     context = setup_context(dev_mode=args.dev_mode)
 
     if args.mode == HyperionMode.GDA:
@@ -188,7 +190,18 @@ def main():
         )
         runner.wait_on_queue()
     else:
-        run_forever(PlanRunner(context))
+        plan_runner = PlanRunner(context, args.dev_mode)
+        create_server_for_udc(plan_runner)
+        _register_sigterm_handler(plan_runner)
+        run_forever(plan_runner)
+
+
+def _register_sigterm_handler(runner: PlanRunner):
+    def shutdown_on_sigterm(sig_num, frame):
+        LOGGER.info("Received SIGTERM, shutting down...")
+        runner.shutdown()
+
+    signal.signal(signal.SIGTERM, shutdown_on_sigterm)
 
 
 if __name__ == "__main__":

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/hyperion/baton_handler.py

@@ -6,8 +6,14 @@ from blueapi.core.context import BlueskyContext
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import MsgGenerator, RunEngineInterrupted
+from dodal.common.beamlines.commissioning_mode import set_commissioning_signal
+from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.baton import Baton
+from dodal.devices.motors import XYZStage
+from dodal.devices.robot import BartRobot
+from dodal.devices.smargon import Smargon
 
+from mx_bluesky.common.device_setup_plans.robot_load_unload import robot_unload
 from mx_bluesky.common.experiment_plans.inner_plans.udc_default_state import (
     UDCDefaultDevices,
     move_to_udc_default_state,
@@ -77,6 +83,7 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
 
     def acquire_baton() -> MsgGenerator:
         yield from _wait_for_hyperion_requested(baton)
+        LOGGER.debug("Hyperion is now current baton holder.")
         yield from bps.abs_set(baton.current_user, HYPERION_USER)
 
     def collect() -> MsgGenerator:
@@ -96,14 +103,20 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
 
         # re-fetch the baton because the device has been reinstantiated
         baton = _get_baton(context)
+        current_visit: str | None = None
         while (yield from _is_requesting_baton(baton)):
-            yield from _fetch_and_process_agamemnon_instruction(baton, runner)
+            current_visit = yield from _fetch_and_process_agamemnon_instruction(
+                baton, runner, current_visit
+            )
+        if current_visit:
+            yield from _perform_robot_unload(runner.context, current_visit)
 
     def release_baton() -> MsgGenerator:
         # 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
         baton = _get_baton(context)
-        previous_requested_user = yield from _safely_release_baton(baton)
+        previous_requested_user = yield from _unrequest_baton(baton)
+        LOGGER.debug("Hyperion no longer current baton holder.")
         yield from bps.abs_set(baton.current_user, NO_USER, wait=True)
         _raise_baton_released_alert(get_alerting_service(), previous_requested_user)
 
@@ -111,11 +124,11 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
         yield from bpp.contingency_wrapper(collect(), final_plan=release_baton)
 
     context.run_engine(acquire_baton())
-    _initialise_udc(context)
+    _initialise_udc(context, runner.is_dev_mode)
     context.run_engine(collect_then_release())
 
 
-def _initialise_udc(context: BlueskyContext):
+def _initialise_udc(context: BlueskyContext, dev_mode: bool):
     """
     Perform all initialisation that happens at the start of UDC just after the
     baton is acquired, but before we execute any plans or move hardware.
@@ -125,21 +138,25 @@ def _initialise_udc(context: BlueskyContext):
     """
     LOGGER.info("Initialising mx-bluesky for UDC start...")
     clear_all_device_caches(context)
-    setup_devices(context, False)
+    LOGGER.debug("Reinitialising beamline devices")
+    setup_devices(context, dev_mode)
+    set_commissioning_signal(_get_baton(context).commissioning)
 
 
 def _wait_for_hyperion_requested(baton: Baton):
+    LOGGER.debug("Hyperion waiting for baton...")
     SLEEP_PER_CHECK = 0.1
     while True:
         requested_user = yield from bps.rd(baton.requested_user)
         if requested_user == HYPERION_USER:
+            LOGGER.debug("Baton requested for Hyperion")
             break
         yield from bps.sleep(SLEEP_PER_CHECK)
 
 
 def _fetch_and_process_agamemnon_instruction(
-    baton: Baton, runner: PlanRunner
-) -> MsgGenerator:
+    baton: Baton, runner: PlanRunner, current_visit: str | None
+) -> MsgGenerator[str | None]:
     parameter_list: Sequence[MxBlueskyParameters] = create_parameters_from_agamemnon()
     if parameter_list:
         for parameters in parameter_list:
@@ -148,6 +165,7 @@ def _fetch_and_process_agamemnon_instruction(
             )
             match parameters:
                 case LoadCentreCollect():
+                    current_visit = parameters.visit
                     devices: Any = create_devices(runner.context)
                     yield from runner.execute_plan(
                         partial(load_centre_collect_full, devices, parameters)
@@ -161,7 +179,8 @@ def _fetch_and_process_agamemnon_instruction(
     else:
         _raise_udc_completed_alert(get_alerting_service())
         # Release the baton for orderly exit from the instruction loop
-        yield from _safely_release_baton(baton)
+        yield from _unrequest_baton(baton)
+    return current_visit
 
 
 def _raise_udc_start_alert(alert_service: AlertService):
@@ -205,7 +224,7 @@ def _get_baton(context: BlueskyContext) -> Baton:
     return find_device_in_context(context, "baton", Baton)
 
 
-def _safely_release_baton(baton: Baton) -> MsgGenerator[str]:
+def _unrequest_baton(baton: Baton) -> MsgGenerator[str]:
     """Relinquish the requested user of the baton if it is not already requested
     by another user.
 
@@ -214,6 +233,17 @@ def _safely_release_baton(baton: Baton) -> MsgGenerator[str]:
     """
     requested_user = yield from bps.rd(baton.requested_user)
     if requested_user == HYPERION_USER:
+        LOGGER.debug("Hyperion no longer requesting baton")
         yield from bps.abs_set(baton.requested_user, NO_USER)
         return NO_USER
     return requested_user
+
+
+def _perform_robot_unload(context: BlueskyContext, visit: str) -> MsgGenerator:
+    robot = find_device_in_context(context, "robot", BartRobot)
+    smargon = find_device_in_context(context, "smargon", Smargon)
+    aperture_scatterguard = find_device_in_context(
+        context, "aperture_scatterguard", ApertureScatterguard
+    )
+    lower_gonio = find_device_in_context(context, "lower_gonio", XYZStage)
+    yield from robot_unload(robot, smargon, aperture_scatterguard, lower_gonio, visit)

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -8,11 +8,13 @@ import pydantic
 from blueapi.core import BlueskyContext
 from bluesky.preprocessors import run_decorator, set_run_key_decorator, subs_wrapper
 from bluesky.utils import MsgGenerator
+from dodal.devices.baton import Baton
 from dodal.devices.oav.oav_parameters import OAVParameters
 
 import mx_bluesky.common.xrc_result as flyscan_result
 from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.common.utils.context import device_composite_from_context
+from mx_bluesky.common.utils.exceptions import CrystalNotFoundException
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.xrc_result import XRayCentreEventHandler
 from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
@@ -36,6 +38,8 @@ from mx_bluesky.hyperion.parameters.rotation import RotationScanPerSweep
 class LoadCentreCollectComposite(RobotLoadThenCentreComposite, RotationScanComposite):
     """Composite that provides access to the required devices."""
 
+    baton: Baton
+
 
 def create_devices(context: BlueskyContext) -> LoadCentreCollectComposite:
     """Create the necessary devices for the plan."""
@@ -51,8 +55,9 @@ def load_centre_collect_full(
     * Load the sample if necessary
     * Move to the specified goniometer start angles
     * Perform optical centring, then X-ray centring
-    * If X-ray centring finds a diffracting centre then move to that centre and
-    * do a collection with the specified parameters.
+    * If X-ray centring finds one or more diffracting centres then for each centre
+     that satisfies the chosen selection function,
+     move to that centre and do a collection with the specified parameters.
     """
 
     get_hyperion_config_client().refresh_cache()
@@ -81,12 +86,18 @@ def load_centre_collect_full(
     )
     def plan_with_callback_subs():
         flyscan_event_handler = XRayCentreEventHandler()
-        yield from subs_wrapper(
-            robot_load_then_xray_centre(
-                composite, parameters.robot_load_then_centre, oav_config_file
-            ),
-            flyscan_event_handler,
-        )
+        try:
+            yield from subs_wrapper(
+                robot_load_then_xray_centre(
+                    composite, parameters.robot_load_then_centre, oav_config_file
+                ),
+                flyscan_event_handler,
+            )
+        except CrystalNotFoundException:
+            if parameters.select_centres.ignore_xtal_not_found:
+                LOGGER.info("Ignoring crystal not found due to parameter settings.")
+            else:
+                raise
 
         locations_to_collect_um: list[np.ndarray]
         samples_to_collect: list[int]

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -1,5 +1,6 @@
 import dataclasses
 import json
+import os
 import re
 import traceback
 from collections.abc import Sequence
@@ -27,7 +28,6 @@ from mx_bluesky.hyperion.parameters.components import Wait
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 
 T = TypeVar("T", bound=WithVisit)
-AGAMEMNON_URL = "http://agamemnon.diamond.ac.uk/"
 MULTIPIN_PREFIX = "multipin"
 MULTIPIN_FORMAT_DESC = "Expected multipin format is multipin_{number_of_wells}x{well_size}+{distance_between_tip_and_first_well}"
 MULTIPIN_REGEX = rf"^{MULTIPIN_PREFIX}_(\d+)x(\d+(?:\.\d+)?)\+(\d+(?:\.\d+)?)$"
@@ -191,7 +191,11 @@ def _get_pin_type_from_agamemnon_collect_parameters(
 
 
 def _get_next_instruction(beamline: str) -> dict:
-    return _get_parameters_from_url(AGAMEMNON_URL + f"getnextcollect/{beamline}")
+    return _get_parameters_from_url(get_agamemnon_url() + f"getnextcollect/{beamline}")
+
+
+def get_agamemnon_url() -> str:
+    return os.environ.get("AGAMEMNON_URL", "http://agamemnon.diamond.ac.uk/")
 
 
 def _get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/hyperion/parameters/constants.py

@@ -56,6 +56,7 @@ class HyperionConstants:
     PARAM = ExperimentParamConstants()
     PLAN = PlanNameConstants()
     WAIT = PlanGroupCheckpointConstants()
+    HYPERION_PORT = 5005
     CALLBACK_0MQ_PROXY_PORTS = (5577, 5578)
     DESCRIPTORS = DocDescriptorNames()
     CONFIG_SERVER_URL = (

{mx_bluesky-1.5.5 → mx_bluesky-1.5.6}/src/mx_bluesky/hyperion/plan_runner.py

@@ -19,12 +19,10 @@ class PlanException(Exception):
 class PlanRunner(BaseRunner):
     """Runner that executes experiments from inside a running Bluesky plan"""
 
-    def __init__(
-        self,
-        context: BlueskyContext,
-    ) -> None:
+    def __init__(self, context: BlueskyContext, dev_mode: bool) -> None:
         super().__init__(context)
         self.current_status: Status = Status.IDLE
+        self.is_dev_mode = dev_mode
 
     def execute_plan(
         self,