mx-bluesky 1.5.8__tar.gz → 1.5.9__tar.gz

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/.github/workflows/_helm.yml

@@ -6,7 +6,6 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-
       - name: checkout repo
         uses: actions/checkout@v4
         with:
@@ -22,6 +21,12 @@ jobs:
         run: |
           echo ${{ secrets.GITHUB_TOKEN }} | helm registry login ghcr.io/${{ github.repository }} --username ${{ github.repository_owner }} --password-stdin
 
+      - name: Get version from Git tag
+        id: meta
+        run: |
+          TAG=${GITHUB_REF#refs/tags/}
+          echo "version=$TAG" >> $GITHUB_OUTPUT
+
       - name: Package and push chart
         if: ${{ github.event_name == 'push' && github.ref_type == 'tag' }}
         run: |

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mx-bluesky
-Version: 1.5.8
+Version: 1.5.9
 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.61.0
+Requires-Dist: dls-dodal==1.62.0
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: build; extra == "dev"

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/pyproject.toml

@@ -48,7 +48,7 @@ dependencies = [
     "ophyd >= 1.10.5",
     "ophyd-async >= 0.10.0a2",
     "bluesky >= 1.13.1",
-    "dls-dodal == 1.61.0",
+    "dls-dodal == 1.62.0",
 ]
 
 
@@ -218,6 +218,7 @@ lint.select = [
     "PT012",  # flake8-pytest-style rules - https://docs.astral.sh/ruff/rules/pytest-raises-with-multiple-statements/#pytest-raises-with-multiple-statements-pt012
     "RUF018", # walrus operators in asserts - https://docs.astral.sh/ruff/rules/assignment-in-assert/
     "TID251", # banned api - https://docs.astral.sh/ruff/rules/banned-api/
+    "INP001", # missing __init__.py - https://docs.astral.sh/ruff/rules/implicit-namespace-package/
 ]
 lint.extend-ignore = [
     "E501", # Line too long
@@ -228,6 +229,9 @@ lint.extend-ignore = [
 # See https://github.com/DiamondLightSource/python-copier-template/issues/154
 # Remove this line to forbid private member access, walrys operators in asserts, banned api in tests
 "tests/**/*" = ["SLF001", "B023", "RUF018", "TID251"]
+".github/**/*" = ["INP001"]
+"docs/**/*" = ["INP001"]
+"utility_scripts/**/*" = ["INP001"]
 
 [tool.ruff.lint.flake8-tidy-imports.banned-api]
 "time.sleep".msg = "Use bps.sleep instead. # noqa will disable this rule for that line. See https://github.com/DiamondLightSource/mx-bluesky/issues/925"
@@ -254,13 +258,3 @@ name = "Beamlines do not import from hyperion"
 type = "forbidden"
 source_modules = "mx_bluesky.beamlines.**"
 forbidden_modules = "mx_bluesky.hyperion.**"
-
-[[tool.importlinter.contracts]]
-name = "Only Hyperion and i04 can import from phase1_zebra"
-type = "forbidden"
-source_modules = ["mx_bluesky.beamlines.**", "mx_bluesky.common.**"]
-forbidden_modules = ["mx_bluesky.phase1_zebra.**"]
-ignore_imports = [
-    "mx_bluesky.beamlines.i04.** -> mx_bluesky.phase1_zebra.**",
-    "mx_bluesky.hyperion.** -> mx_bluesky.phase1_zebra.**",
-]

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/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.8'
-__version_tuple__ = version_tuple = (1, 5, 8)
+__version__ = version = '1.5.9'
+__version_tuple__ = version_tuple = (1, 5, 9)
 
-__commit_id__ = commit_id = 'gc6d1815ac'
+__commit_id__ = commit_id = 'g65ec4a831'

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/src/mx_bluesky/beamlines/i04/experiment_plans/i04_grid_detect_then_xray_centre_plan.py

@@ -6,7 +6,7 @@ import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
 from bluesky.utils import MsgGenerator
 from dodal.common import inject
-from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
 from dodal.devices.common_dcm import BaseDCM
@@ -17,6 +17,7 @@ from dodal.devices.fast_grid_scan import (
     set_fast_grid_scan_params,
 )
 from dodal.devices.flux import Flux
+from dodal.devices.i04.transfocator import Transfocator
 from dodal.devices.mx_phase1.beamstop import Beamstop
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
@@ -33,6 +34,10 @@ from dodal.plans.preprocessors.verify_undulator_gap import (
     verify_undulator_gap_before_run_decorator,
 )
 
+from mx_bluesky.common.device_setup_plans.setup_zebra_and_shutter import (
+    setup_zebra_for_gridscan,
+    tidy_up_zebra_after_gridscan,
+)
 from mx_bluesky.common.experiment_plans.common_flyscan_xray_centre_plan import (
     BeamlineSpecificFGSFeatures,
     construct_beamline_specific_FGS_features,
@@ -67,10 +72,22 @@ from mx_bluesky.common.preprocessors.preprocessors import (
     transmission_and_xbpm_feedback_for_collection_decorator,
 )
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.phase1_zebra.device_setup_plans.setup_zebra import (
-    setup_zebra_for_gridscan,
-    tidy_up_zebra_after_gridscan,
-)
+
+DEFAULT_BEAMSIZE_MICRONS = 20
+
+
+def _change_beamsize(
+    transfocator: Transfocator, beamsize: float, parameters: GridCommon
+):
+    """i04 always uses the large aperture and changes beamsize with the transfocator.
+
+    An aperture is needed to reduce scatter but the transfocator is best used for beamsize
+    changes as it gives more flux compared to a bigger beam with a small aperture.
+    """
+    parameters.selected_aperture = ApertureValue.LARGE
+    yield from bps.abs_set(
+        transfocator, beamsize, group=PlanGroupCheckpointConstants.GRID_READY_FOR_DC
+    )
 
 
 # See https://github.com/DiamondLightSource/blueapi/issues/506 for using device composites
@@ -96,6 +113,7 @@ def i04_grid_detect_then_xray_centre(
     zocalo: ZocaloResults = inject("zocalo"),
     smargon: Smargon = inject("smargon"),
     detector_motion: DetectorMotion = inject("detector_motion"),
+    transfocator: Transfocator = inject("transfocator"),
     oav_config: str = OavConstants.OAV_CONFIG_JSON,
     udc: bool = False,
 ) -> MsgGenerator:
@@ -108,7 +126,7 @@ def i04_grid_detect_then_xray_centre(
 
 
     i04's implementation of this plan is very similar to Hyperion. However, since i04
-    isn't running in a continious Bluesky UDC loop, we take additional steps in beamline
+    isn't running in a continuous Bluesky UDC loop, we take additional steps in beamline
     tidy-up.
     """
 
@@ -134,8 +152,9 @@ def i04_grid_detect_then_xray_centre(
         robot,
         sample_shutter,
     )
+    initial_beamsize = yield from bps.rd(transfocator.beamsize_set_microns)
 
-    def tidy_beamline_if_not_udc():
+    def tidy_beamline():
         if not udc:
             yield from get_ready_for_oav_and_close_shutter(
                 composite.smargon,
@@ -143,8 +162,9 @@ def i04_grid_detect_then_xray_centre(
                 composite.aperture_scatterguard,
                 composite.detector_motion,
             )
+        yield from bps.mv(transfocator, initial_beamsize)
 
-    @bpp.finalize_decorator(tidy_beamline_if_not_udc)
+    @bpp.finalize_decorator(tidy_beamline)
     def _inner_grid_detect_then_xrc():
         # These callbacks let us talk to ISPyB and Nexgen. They aren't included in the common plan because
         # Hyperion handles its callbacks differently to BlueAPI-managed plans, see
@@ -167,6 +187,7 @@ def i04_grid_detect_then_xray_centre(
 
         yield from grid_detect_then_xray_centre_with_callbacks()
 
+    yield from _change_beamsize(transfocator, DEFAULT_BEAMSIZE_MICRONS, parameters)
     yield from _inner_grid_detect_then_xrc()
 
 
@@ -178,7 +199,7 @@ def get_ready_for_oav_and_close_shutter(
 ):
     yield from bps.wait(PlanGroupCheckpointConstants.GRID_READY_FOR_DC)
     group = "get_ready_for_oav_and_close_shutter"
-    LOGGER.info("Non-udc tidy: Seting up beamline for OAV")
+    LOGGER.info("Non-udc tidy: Setting up beamline for OAV")
     yield from setup_beamline_for_OAV(
         smargon, backlight, aperture_scatterguard, group=group
     )
@@ -247,7 +268,9 @@ def construct_i04_specific_features(
     )
     fgs_motors = xrc_composite.zebra_fast_grid_scan
     return construct_beamline_specific_FGS_features(
-        setup_zebra_for_gridscan,
+        partial(
+            setup_zebra_for_gridscan,
+        ),
         tidy_plan,
         set_flyscan_params_plan,
         fgs_motors,

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/src/mx_bluesky/common/device_setup_plans/manipulate_sample.py

@@ -9,8 +9,8 @@ from dodal.devices.backlight import Backlight, InOut
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.smargon import CombinedMove, Smargon
 
+from mx_bluesky.common.parameters.constants import PlanGroupCheckpointConstants
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.parameters.constants import CONST
 
 LOWER_DETECTOR_SHUTTER_AFTER_SCAN = True
 
@@ -48,7 +48,7 @@ def move_aperture_if_required(
 
     else:
         LOGGER.info(f"Setting aperture position to {aperture_value}")
-        yield from bps.wait(CONST.WAIT.PREPARE_APERTURE)
+        yield from bps.wait(PlanGroupCheckpointConstants.PREPARE_APERTURE)
         yield from bps.abs_set(
             aperture_scatterguard.selected_aperture,
             aperture_value,

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/src/mx_bluesky/common/device_setup_plans/robot_load_unload.py

@@ -9,8 +9,12 @@ from dodal.devices.robot import BartRobot
 from dodal.devices.smargon import CombinedMove, Smargon, StubPosition
 from dodal.plan_stubs.motor_utils import MoveTooLarge, home_and_reset_wrapper
 
+from mx_bluesky.common.parameters.constants import (
+    DocDescriptorNames,
+    HardwareConstants,
+    PlanNameConstants,
+)
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.parameters.constants import CONST
 
 SLEEP_PER_CHECK = 0.1
 
@@ -60,7 +64,7 @@ def do_plan_while_lower_gonio_at_home(plan: MsgGenerator, lower_gonio: XYZStage)
             plan,
             lower_gonio,
             BartRobot.LOAD_TOLERANCE_MM,
-            CONST.HARDWARE.CRYOJET_MARGIN_MM,
+            HardwareConstants.CRYOJET_MARGIN_MM,
             "lower_gonio",
             wait_for_all=False,
         ),
@@ -100,7 +104,7 @@ def robot_unload(
 
     @bpp.run_decorator(
         md={
-            "subplan_name": CONST.PLAN.ROBOT_UNLOAD,
+            "subplan_name": PlanNameConstants.ROBOT_UNLOAD,
             "metadata": {"visit": visit, "sample_id": sample_id},
             "activate_callbacks": [
                 "RobotLoadISPyBCallback",
@@ -108,7 +112,7 @@ def robot_unload(
         },
     )
     def do_robot_unload_and_send_to_ispyb():
-        yield from bps.create(name=CONST.DESCRIPTORS.ROBOT_UPDATE)
+        yield from bps.create(name=DocDescriptorNames.ROBOT_UPDATE)
         yield from bps.read(robot)
         yield from bps.save()
 

mx_bluesky-1.5.9/src/mx_bluesky/common/device_setup_plans/setup_zebra_and_shutter.py

@@ -0,0 +1,245 @@
+from typing import Protocol, runtime_checkable
+
+import bluesky.plan_stubs as bps
+from bluesky.utils import MsgGenerator
+from dodal.devices.zebra.zebra import (
+    ArmDemand,
+    EncEnum,
+    I03Axes,
+    RotationDirection,
+    Zebra,
+)
+from dodal.devices.zebra.zebra_controlled_shutter import (
+    ZebraShutter,
+    ZebraShutterControl,
+)
+
+from mx_bluesky.common.parameters.constants import ZEBRA_STATUS_TIMEOUT
+from mx_bluesky.common.utils.log import LOGGER
+
+"""Plans in this file will work as intended if the zebra has the following configuration:
+- A fast shutter is connected through TTL inputs from the Zebra.
+- When the zebra shutter is set to auto mode, the IOC sets the Zebra's SOFT_IN1 signal high.
+- When the zebra shutter is set to manual mode, the IOC sets the Zebra's SOFT_IN1 signal low.
+"""
+
+
+@runtime_checkable
+class GridscanSetupDevices(Protocol):
+    zebra: Zebra
+    sample_shutter: ZebraShutter
+
+
+def setup_zebra_for_gridscan(
+    composite: GridscanSetupDevices,  # XRC gridscan's generic trigger setup expects a composite rather than individual devices
+    group="setup_zebra_for_gridscan",
+    wait=True,
+    ttl_input_for_detector_to_use: None | int = None,
+) -> MsgGenerator:
+    """
+    Configure the zebra for an MX XRC gridscan by allowing the zebra to trigger the fast shutter and detector via signals
+    sent from the motion controller.
+
+    Args:
+        composite: Composite device containing a zebra and zebra shutter
+        group: Bluesky group to use when waiting on completion
+        wait: If true, block until completion
+        ttl_input_for_detector_to_use: If the zebra isn't using the TTL_DETECTOR zebra input, manually
+        specify which TTL input is being used for the desired detector
+
+    This plan assumes that the motion controller, as part of its gridscan PLC, will send triggers as required to the zebra's
+    IN4_TTL and IN3_TTL to control the fast_shutter and detector respectively
+
+    """
+    zebra = composite.zebra
+    ttl_detector = ttl_input_for_detector_to_use or zebra.mapping.outputs.TTL_DETECTOR
+    # Set shutter to automatic and to trigger via motion controller GPIO signal (IN4_TTL)
+    yield from configure_zebra_and_shutter_for_auto_shutter(
+        zebra, composite.sample_shutter, zebra.mapping.sources.IN4_TTL, group=group
+    )
+
+    yield from bps.abs_set(
+        zebra.output.out_pvs[ttl_detector],
+        zebra.mapping.sources.IN3_TTL,
+        group=group,
+    )
+
+    if wait:
+        yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
+
+
+def set_shutter_auto_input(zebra: Zebra, input: int, group="set_shutter_trigger"):
+    """Set the signal that controls the shutter. We use the second input to the
+    Zebra's AND_GATE_FOR_AUTO_SHUTTER for this input. ZebraShutter control mode must be in auto for this input to take control
+
+    For more details see the ZebraShutter device."""
+    auto_gate = zebra.mapping.AND_GATE_FOR_AUTO_SHUTTER
+    auto_shutter_control = zebra.logic_gates.and_gates[auto_gate]
+    yield from bps.abs_set(auto_shutter_control.sources[2], input, group)
+
+
+def configure_zebra_and_shutter_for_auto_shutter(
+    zebra: Zebra, zebra_shutter: ZebraShutter, input: int, group="use_automatic_shutter"
+):
+    """Set the shutter to auto mode, and configure the zebra to trigger the shutter on
+    an input source. For the input, use one of the source constants in zebra.py
+
+    When the shutter is in auto/manual, logic in EPICS sets the Zebra's
+    SOFT_IN1 to low/high respectively. The Zebra's AND_GATE_FOR_AUTO_SHUTTER should be used to control the shutter while in auto mode.
+    To do this, we need (AND_GATE_FOR_AUTO_SHUTTER = SOFT_IN1 AND input), where input is the zebra signal we want to control the shutter when in auto mode.
+    """
+
+    # Set shutter to auto mode
+    yield from bps.abs_set(
+        zebra_shutter.control_mode, ZebraShutterControl.AUTO, group=group
+    )
+
+    auto_gate = zebra.mapping.AND_GATE_FOR_AUTO_SHUTTER
+
+    # Set first input of AND_GATE_FOR_AUTO_SHUTTER to SOFT_IN1, which is high when shutter is in auto mode
+    # Note the Zebra should ALWAYS be setup this way. See https://github.com/DiamondLightSource/mx-bluesky/issues/551
+    yield from bps.abs_set(
+        zebra.logic_gates.and_gates[auto_gate].sources[1],
+        zebra.mapping.sources.SOFT_IN1,
+        group=group,
+    )
+
+    # Set the second input of AND_GATE_FOR_AUTO_SHUTTER to the requested zebra input source
+    yield from set_shutter_auto_input(zebra, input, group=group)
+
+
+def tidy_up_zebra_after_gridscan(
+    zebra: Zebra,
+    zebra_shutter: ZebraShutter,
+    group="tidy_up_zebra_after_gridscan",
+    wait=True,
+    ttl_input_for_detector_to_use: int | None = None,
+) -> MsgGenerator:
+    """
+    Set the zebra back to a state which is expected by GDA.
+
+    Args:
+        zebra: Zebra device.
+        zebra_shutter: Zebra shutter device.
+        group: Bluesky group to use when waiting on completion.
+        wait: If true, block until completion.
+        ttl_input_for_detector_to_use: If the zebra isn't using the TTL_DETECTOR zebra input, manually
+        specify which TTL input is being used for the desired detector.
+    """
+
+    LOGGER.info("Tidying up Zebra")
+
+    ttl_detector = ttl_input_for_detector_to_use or zebra.mapping.outputs.TTL_DETECTOR
+
+    yield from bps.abs_set(
+        zebra.output.out_pvs[ttl_detector],
+        zebra.mapping.sources.PC_PULSE,
+        group=group,
+    )
+    yield from bps.abs_set(
+        zebra_shutter.control_mode, ZebraShutterControl.MANUAL, group=group
+    )
+    yield from set_shutter_auto_input(zebra, zebra.mapping.sources.PC_GATE, group=group)
+
+    if wait:
+        yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
+
+
+def setup_zebra_for_rotation(
+    zebra: Zebra,
+    zebra_shutter: ZebraShutter,
+    axis: EncEnum = I03Axes.OMEGA,
+    start_angle: float = 0,
+    scan_width: float = 360,
+    shutter_opening_deg: float = 2.5,
+    shutter_opening_s: float = 0.04,
+    direction: RotationDirection = RotationDirection.POSITIVE,
+    group: str = "setup_zebra_for_rotation",
+    wait: bool = True,
+    ttl_input_for_detector_to_use: int | None = None,
+):
+    """Set up the Zebra to collect a rotation dataset. Any plan using this is
+    responsible for setting the smargon velocity appropriately so that the desired
+    image width is achieved with the exposure time given here.
+
+    Parameters:
+        zebra:              The zebra device to use
+        axis:               Encoder enum representing which axis to use for position
+                            compare. Currently always omega.
+        start_angle:        Position at which the scan should begin, in degrees.
+        scan_width:         Total angle through which to collect, in degrees.
+        shutter_opening_deg:How many degrees of rotation it takes for the fast shutter
+                            to open. Increases the gate width.
+        shutter_opening_s:  How many seconds it takes for the fast shutter to open. The
+                            detector pulse is delayed after the shutter signal by this
+                            amount.
+        direction:          RotationDirection enum for positive or negative.
+                            Defaults to Positive.
+        group:              A name for the group of statuses generated
+        wait:               Block until all the settings have completed
+        ttl_input_for_detector_to_use: If the zebra isn't using the TTL_DETECTOR zebra input,
+                            manually specify which TTL input is being used for the desired detector
+    """
+
+    ttl_detector = ttl_input_for_detector_to_use or zebra.mapping.outputs.TTL_DETECTOR
+
+    if not isinstance(direction, RotationDirection):
+        raise ValueError(
+            "Disallowed rotation direction provided to Zebra setup plan. "
+            "Use RotationDirection.POSITIVE or RotationDirection.NEGATIVE."
+        )
+    yield from bps.abs_set(zebra.pc.dir, direction.value, group=group)
+    LOGGER.info("ZEBRA SETUP: START")
+    # Set gate start, adjust for shutter opening time if necessary
+    LOGGER.info(f"ZEBRA SETUP: degrees to adjust for shutter = {shutter_opening_deg}")
+    LOGGER.info(f"ZEBRA SETUP: start angle start: {start_angle}")
+    LOGGER.info(f"ZEBRA SETUP: start angle adjusted, gate start set to: {start_angle}")
+    yield from bps.abs_set(zebra.pc.gate_start, start_angle, group=group)
+    # set gate width to total width
+    yield from bps.abs_set(
+        zebra.pc.gate_width, scan_width + shutter_opening_deg, group=group
+    )
+    LOGGER.info(
+        f"Pulse start set to shutter open time, set to: {abs(shutter_opening_s)}"
+    )
+    yield from bps.abs_set(zebra.pc.pulse_start, abs(shutter_opening_s), group=group)
+    # Set gate position to be angle of interest
+    yield from bps.abs_set(zebra.pc.gate_trigger, axis.value, group=group)
+    # Set shutter to automatic and to trigger via PC_GATE
+    yield from configure_zebra_and_shutter_for_auto_shutter(
+        zebra, zebra_shutter, zebra.mapping.sources.PC_GATE, group=group
+    )
+    # Trigger the detector with a pulse
+    yield from bps.abs_set(
+        zebra.output.out_pvs[ttl_detector],
+        zebra.mapping.sources.PC_PULSE,
+        group=group,
+    )
+
+    LOGGER.info(f"ZEBRA SETUP: END - {'' if wait else 'not'} waiting for completion")
+    if wait:
+        yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
+
+
+def tidy_up_zebra_after_rotation_scan(
+    zebra: Zebra,
+    zebra_shutter: ZebraShutter,
+    group="tidy_up_zebra_after_rotation",
+    wait=True,
+):
+    """
+    Set the zebra back to a state which is expected by GDA.
+
+    Args:
+        zebra: Zebra device.
+        zebra_shutter: Zebra shutter device.
+        group: Bluesky group to use when waiting on completion.
+        wait: If true, block until completion.
+    """
+
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, group=group)
+    yield from bps.abs_set(
+        zebra_shutter.control_mode, ZebraShutterControl.MANUAL, group=group
+    )
+    if wait:
+        yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/src/mx_bluesky/common/experiment_plans/common_flyscan_xray_centre_plan.py

@@ -8,11 +8,12 @@ import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
 import numpy as np
 from bluesky.protocols import Readable
-from bluesky.utils import MsgGenerator
+from bluesky.utils import FailedStatus, MsgGenerator
 from dodal.common.beamlines.commissioning_mode import read_commissioning_mode
 from dodal.devices.fast_grid_scan import (
     FastGridScanCommon,
     FastGridScanThreeD,
+    GridScanInvalidException,
 )
 from dodal.devices.zocalo import ZocaloResults
 from dodal.devices.zocalo.zocalo_results import (
@@ -270,10 +271,14 @@ def run_gridscan(
         yield from beamline_specific.read_pre_flyscan_plan()
 
     LOGGER.info("Setting fgs params")
-    yield from beamline_specific.set_flyscan_params_plan()
 
-    LOGGER.info("Waiting for gridscan validity check")
-    yield from wait_for_gridscan_valid(beamline_specific.fgs_motors)
+    try:
+        yield from beamline_specific.set_flyscan_params_plan()
+    except FailedStatus as e:
+        if isinstance(e.__cause__, GridScanInvalidException):
+            raise SampleException(
+                "Scan invalid - gridscan not valid for detected pin position"
+            ) from e
 
     LOGGER.info("Waiting for arming to finish")
     yield from bps.wait(PlanGroupCheckpointConstants.GRID_READY_FOR_DC)
@@ -293,23 +298,6 @@ def run_gridscan(
         yield from bps.abs_set(beamline_specific.fgs_motors.z_steps, 0, wait=False)
 
 
-def wait_for_gridscan_valid(fgs_motors: FastGridScanCommon, timeout=0.5):
-    LOGGER.info("Waiting for valid fgs_params")
-    SLEEP_PER_CHECK = 0.1
-    times_to_check = int(timeout / SLEEP_PER_CHECK)
-    for _ in range(times_to_check):
-        scan_invalid = yield from bps.rd(fgs_motors.scan_invalid)
-        pos_counter = yield from bps.rd(fgs_motors.position_counter)
-        LOGGER.debug(
-            f"Scan invalid: {scan_invalid} and position counter: {pos_counter}"
-        )
-        if not scan_invalid and pos_counter == 0:
-            LOGGER.info("Gridscan scan valid and position counter reset")
-            return
-        yield from bps.sleep(SLEEP_PER_CHECK)
-    raise SampleException("Scan invalid - pin too long/short/bent and out of range")
-
-
 def _xrc_result_in_boxes_to_result_in_mm(
     xrc_result: XrcResult, parameters: SpecifiedThreeDGridScan
 ) -> XRayCentreResult:

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/src/mx_bluesky/common/experiment_plans/inner_plans/do_fgs.py

@@ -94,8 +94,10 @@ def kickoff_and_complete_gridscan(
         md={
             "subplan_name": plan_name,
             "omega_to_scan_spec": {
-                GridscanPlane.OMEGA_XY: scan_points[0],
-                GridscanPlane.OMEGA_XZ: scan_points[1],
+                # These have to be cast to strings due to a bug in orsjon. See
+                # https://github.com/ijl/orjson/issues/414
+                str(GridscanPlane.OMEGA_XY): scan_points[0],
+                str(GridscanPlane.OMEGA_XZ): scan_points[1],
             },
         }
     )

{mx_bluesky-1.5.8 → mx_bluesky-1.5.9}/src/mx_bluesky/common/external_interaction/callbacks/common/ispyb_mapping.py

@@ -50,9 +50,10 @@ def populate_remaining_data_collection_info(
     data_collection_info.xbeam = beam_position[0]
     data_collection_info.ybeam = beam_position[1]
     data_collection_info.start_time = get_current_time_string()
-    # temporary file template until nxs filewriting is integrated and we can use
-    # that file name
-    data_collection_info.file_template = f"{params.detector_params.prefix}_{data_collection_info.data_collection_number}_master.h5"
+    if data_collection_info.data_collection_number is not None:
+        # Do not write the file template if we don't have sufficient information - for gridscans we  may not
+        # know the data collection number until later
+        data_collection_info.file_template = f"{params.detector_params.prefix}_{data_collection_info.data_collection_number}_master.h5"
     return data_collection_info