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

mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -0,0 +1,242 @@
+import dataclasses
+import json
+import re
+from os import path
+from typing import Any, TypeVar
+
+import requests
+from deepdiff.diff import DeepDiff
+from dodal.utils import get_beamline_name
+from jsonschema import ValidationError
+from pydantic_extra_types.semantic_version import SemanticVersion
+
+from mx_bluesky.common.parameters.components import (
+    PARAMETER_VERSION,
+    MxBlueskyParameters,
+    TopNByMaxCountSelection,
+    WithCentreSelection,
+    WithOptionalEnergyChange,
+    WithSample,
+    WithVisit,
+)
+from mx_bluesky.common.parameters.constants import (
+    GridscanParamConstants,
+)
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.common.utils.utils import convert_angstrom_to_eV
+from mx_bluesky.hyperion.parameters.components import WithHyperionUDCFeatures
+from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+from mx_bluesky.hyperion.parameters.robot_load import RobotLoadThenCentre
+
+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+)?)$"
+MX_GENERAL_ROOT_REGEX = r"^/dls/(?P<beamline>[^/]+)/data/[^/]*/(?P<visit>[^/]+)(?:/|$)"
+
+
+class AgamemnonLoadCentreCollect(
+    MxBlueskyParameters,
+    WithVisit,
+    WithSample,
+    WithCentreSelection,
+    WithHyperionUDCFeatures,
+    WithOptionalEnergyChange,
+):
+    """Experiment parameters to compare against GDA populated LoadCentreCollect."""
+
+    robot_load_then_centre: RobotLoadThenCentre
+
+
+@dataclasses.dataclass
+class PinType:
+    expected_number_of_crystals: int
+    single_well_width_um: float
+    tip_to_first_well_um: float = 0
+
+    @property
+    def full_width(self) -> float:
+        """This is the "width" of the area where there may be samples.
+
+        From a pin perspective this is along the length of the pin but we use width here as
+        we mount the sample at 90 deg to the optical camera.
+
+        We calculate the full width by adding all the gaps between wells then assuming
+        there is a buffer of {tip_to_first_well_um} either side too. In reality the
+        calculation does not need to be very exact as long as we get a width that's good
+        enough to use for optical centring and XRC grid size.
+        """
+        return (self.expected_number_of_crystals - 1) * self.single_well_width_um + (
+            2 * self.tip_to_first_well_um
+        )
+
+
+class SinglePin(PinType):
+    def __init__(self):
+        super().__init__(1, GridscanParamConstants.WIDTH_UM)
+
+    @property
+    def full_width(self) -> float:
+        return self.single_well_width_um
+
+
+def _get_parameters_from_url(url: str) -> dict:
+    response = requests.get(url, headers={"Accept": "application/json"})
+    response.raise_for_status()
+    response_json = json.loads(response.content)
+    try:
+        return response_json["collect"]
+    except KeyError as e:
+        raise KeyError(f"Unexpected json from agamemnon: {response_json}") from e
+
+
+def get_pin_type_from_agamemnon_parameters(parameters: dict) -> PinType:
+    loop_type_name: str | None = parameters["sample"]["loopType"]
+    if loop_type_name:
+        regex_search = re.search(MULTIPIN_REGEX, loop_type_name)
+        if regex_search:
+            wells, well_size, tip_to_first_well = regex_search.groups()
+            return PinType(int(wells), float(well_size), float(tip_to_first_well))
+        else:
+            loop_type_message = (
+                f"Agamemnon loop type of {loop_type_name} not recognised"
+            )
+            if loop_type_name.startswith(MULTIPIN_PREFIX):
+                raise ValueError(f"{loop_type_message}. {MULTIPIN_FORMAT_DESC}")
+            LOGGER.warning(f"{loop_type_message}, assuming single pin")
+    return SinglePin()
+
+
+def get_next_instruction(beamline: str) -> dict:
+    return _get_parameters_from_url(AGAMEMNON_URL + f"getnextcollect/{beamline}")
+
+
+def get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
+    try:
+        prefix = parameters["prefix"]
+        collection = parameters["collection"]
+        # Assuming distance is identical for multiple collections. Remove after https://github.com/DiamondLightSource/mx-bluesky/issues/773
+        detector_distance = collection[0]["distance"]
+    except KeyError as e:
+        raise KeyError("Unexpected json from agamemnon") from e
+
+    match = re.match(MX_GENERAL_ROOT_REGEX, prefix) if prefix else None
+
+    if match:
+        return (match.group("visit"), detector_distance)
+
+    raise ValueError(
+        f"Agamemnon prefix '{prefix}' does not match MX-General root structure"
+    )
+
+
+def get_withsample_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
+    assert parameters.get("sample"), "instruction does not have a sample"
+    return {
+        "sample_id": parameters["sample"]["id"],
+        "sample_puck": parameters["sample"]["container"],
+        "sample_pin": parameters["sample"]["position"],
+    }
+
+
+def get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
+    try:
+        first_collection: dict = parameters["collection"][0]
+        wavelength = first_collection.get("wavelength")
+        assert isinstance(wavelength, float)
+        demand_energy_ev = convert_angstrom_to_eV(wavelength)
+        return {"demand_energy_ev": demand_energy_ev}
+    except (KeyError, IndexError, AttributeError, TypeError):
+        return {"demand_energy_ev": None}
+
+
+def get_param_version() -> SemanticVersion:
+    return SemanticVersion.validate_from_str(str(PARAMETER_VERSION))
+
+
+def create_robot_load_then_centre_params_from_agamemnon(
+    parameters: dict,
+) -> RobotLoadThenCentre:
+    visit, detector_distance = get_withvisit_parameters_from_agamemnon(parameters)
+    with_sample_params = get_withsample_parameters_from_agamemnon(parameters)
+    with_energy_params = get_withenergy_parameters_from_agamemnon(parameters)
+    visit_directory, file_name = path.split(parameters["prefix"])
+    return RobotLoadThenCentre(
+        parameter_model_version=get_param_version(),
+        storage_directory=visit_directory + "/xraycentring",
+        visit=visit,
+        detector_distance_mm=detector_distance,
+        snapshot_directory=visit_directory + "/snapshots",
+        file_name=file_name,
+        **with_energy_params,
+        **with_sample_params,
+    )
+
+
+def populate_parameters_from_agamemnon(agamemnon_params):
+    visit, detector_distance = get_withvisit_parameters_from_agamemnon(agamemnon_params)
+    with_sample_params = get_withsample_parameters_from_agamemnon(agamemnon_params)
+    with_energy_params = get_withenergy_parameters_from_agamemnon(agamemnon_params)
+    pin_type = get_pin_type_from_agamemnon_parameters(agamemnon_params)
+    robot_load_params = create_robot_load_then_centre_params_from_agamemnon(
+        agamemnon_params
+    )
+    return AgamemnonLoadCentreCollect(
+        parameter_model_version=SemanticVersion.validate_from_str(
+            str(PARAMETER_VERSION)
+        ),
+        visit=visit,
+        detector_distance_mm=detector_distance,
+        select_centres=TopNByMaxCountSelection(n=pin_type.expected_number_of_crystals),
+        robot_load_then_centre=robot_load_params,
+        **with_sample_params,
+        **with_energy_params,
+    )
+
+
+def create_parameters_from_agamemnon() -> AgamemnonLoadCentreCollect:
+    beamline_name = get_beamline_name("i03")
+    agamemnon_params = get_next_instruction(beamline_name)
+
+    return populate_parameters_from_agamemnon(agamemnon_params)
+
+
+def compare_params(load_centre_collect_params):
+    try:
+        parameters = create_parameters_from_agamemnon()
+
+        # Log differences against GDA populated parameters
+        differences = DeepDiff(
+            parameters, load_centre_collect_params, math_epsilon=1e-5
+        )
+        if differences:
+            LOGGER.info(
+                f"Different parameters found when directly reading from Hyperion: {differences}"
+            )
+    except (ValueError, KeyError) as e:
+        LOGGER.warning(f"Failed to compare parameters: {e}")
+    except Exception as e:
+        LOGGER.warning(f"Unexpected error occurred. Failed to compare parameters: {e}")
+
+
+def update_params_from_agamemnon(parameters: T) -> T:
+    try:
+        beamline_name = get_beamline_name("i03")
+        agamemnon_params = get_next_instruction(beamline_name)
+        pin_type = get_pin_type_from_agamemnon_parameters(agamemnon_params)
+        if isinstance(parameters, LoadCentreCollect):
+            parameters.robot_load_then_centre.tip_offset_um = pin_type.full_width / 2
+            parameters.robot_load_then_centre.grid_width_um = pin_type.full_width
+            parameters.select_centres.n = pin_type.expected_number_of_crystals
+            if pin_type != SinglePin():
+                # Snapshots between each collection take a lot of time.
+                # Before we do https://github.com/DiamondLightSource/mx-bluesky/issues/226
+                # this will give no snapshots but that's preferable
+                parameters.multi_rotation_scan.snapshot_omegas_deg = []
+    except (ValueError, ValidationError) as e:
+        LOGGER.warning(f"Failed to update parameters: {e}")
+    except Exception as e:
+        LOGGER.warning(f"Unexpected error occurred. Failed to update parameters: {e}")
+
+    return parameters

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -1,8 +1,8 @@
 import logging
 from collections.abc import Callable, Sequence
 from threading import Thread
-from time import sleep
 
+import bluesky.plan_stubs as bps
 from bluesky.callbacks import CallbackBase
 from bluesky.callbacks.zmq import Proxy, RemoteDispatcher
 from dodal.log import LOGGER as dodal_logger
@@ -14,6 +14,9 @@ from mx_bluesky.common.external_interaction.callbacks.common.log_uid_tag_callbac
 from mx_bluesky.common.external_interaction.callbacks.common.zocalo_callback import (
     ZocaloCallback,
 )
+from mx_bluesky.common.external_interaction.callbacks.sample_handling.sample_handling_callback import (
+    SampleHandlingCallback,
+)
 from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_callback import (
     GridscanISPyBCallback,
 )
@@ -35,8 +38,8 @@ from mx_bluesky.hyperion.external_interaction.callbacks.rotation.ispyb_callback
 from mx_bluesky.hyperion.external_interaction.callbacks.rotation.nexus_callback import (
     RotationNexusFileCallback,
 )
-from mx_bluesky.hyperion.external_interaction.callbacks.sample_handling.sample_handling_callback import (
-    SampleHandlingCallback,
+from mx_bluesky.hyperion.external_interaction.callbacks.snapshot_callback import (
+    BeamDrawingCallback,
 )
 from mx_bluesky.hyperion.parameters.cli import parse_callback_dev_mode_arg
 from mx_bluesky.hyperion.parameters.constants import CONST
@@ -67,15 +70,18 @@ def create_rotation_callbacks() -> tuple[
     return (
         RotationNexusFileCallback(),
         RotationISPyBCallback(
-            emit=ZocaloCallback(CONST.PLAN.ROTATION_MAIN, CONST.ZOCALO_ENV)
+            emit=ZocaloCallback(CONST.PLAN.ROTATION_MULTI, CONST.ZOCALO_ENV)
         ),
     )
 
 
 def setup_callbacks() -> list[CallbackBase]:
+    rot_nexus_cb, rot_ispyb_cb = create_rotation_callbacks()
+    snapshot_cb = BeamDrawingCallback(emit=rot_ispyb_cb)
     return [
         *create_gridscan_callbacks(),
-        *create_rotation_callbacks(),
+        rot_nexus_cb,
+        snapshot_cb,
         LogUidTaggingCallback(),
         RobotLoadISPyBCallback(),
         SampleHandlingCallback(),
@@ -134,7 +140,7 @@ def wait_for_threads_forever(threads: Sequence[Thread]):
     try:
         log_debug("Trying to wait forever on callback and dispatcher threads")
         while all(alive):
-            sleep(LIVENESS_POLL_SECONDS)
+            yield from bps.sleep(LIVENESS_POLL_SECONDS)
             alive = [t.is_alive() for t in threads]
     except KeyboardInterrupt:
         log_info("Main thread received interrupt - exiting.")

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

@@ -136,7 +136,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
             "handle_ispyb_hardware_read triggered before activity_gated_start"
         )
         motor_positions_um = [position * 1000 for position in motor_positions_mm]
-        comment = f"Sample position (µm): ({motor_positions_um[0]:.0f}, {motor_positions_um[1]:.0f}, {motor_positions_um[2]:.0f}) {self.params.comment} "
+        comment = f"Sample position (µm): ({motor_positions_um[0]:.0f}, {motor_positions_um[1]:.0f}, {motor_positions_um[2]:.0f})"
         scan_data_infos[0].data_collection_info.comments = comment
         return scan_data_infos
 

mx_bluesky/hyperion/external_interaction/callbacks/snapshot_callback.py

@@ -0,0 +1,107 @@
+import re
+
+from dodal.devices.oav.snapshots.snapshot_image_processing import (
+    compute_beam_centre_pixel_xy_for_mm_position,
+    draw_crosshair,
+)
+from event_model import Event, EventDescriptor, RunStart
+from PIL import Image
+
+from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
+    PlanReactiveCallback,
+)
+from mx_bluesky.common.parameters.constants import DocDescriptorNames
+from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER as CALLBACK_LOGGER
+
+
+class BeamDrawingCallback(PlanReactiveCallback):
+    """
+    Callback that monitors for OAV_ROTATION_SNAPSHOT_TRIGGERED events and
+    draws a crosshair at the beam centre, saving the snapshot to a file.
+    The callback assumes an OAV device "oav"
+    Examples:
+        Take a snapshot at the current location
+    >>> from bluesky.run_engine import RunEngine
+    >>> import bluesky.preprocessors as bpp
+    >>> import bluesky.plan_stubs as bps
+    >>> from dodal.devices.oav.oav_detector import OAV
+    >>> from mx_bluesky.common.parameters.components import WithSnapshot
+    >>> def take_snapshot(params: WithSnapshot, oav: OAV, run_engine: RunEngine):
+    ...     run_engine.subscribe(BeamDrawingCallback())
+    ...     @bpp.run_decorator(md={
+    ...     "activate_callbacks": ["BeamDrawingCallback"],
+    ...         "with_snapshot": params.model_dump_json(),
+    ...     })
+    ...     def inner_plan():
+    ...         yield from bps.abs_set(oav.snapshot.directory, "/path/to/snapshot_folder", wait=True)
+    ...         yield from bps.abs_set(oav.snapshot.filename, "my_snapshot_prefix", wait=True)
+    ...         yield from bps.trigger(oav.snapshot, wait=True)
+    ...         yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
+    ...         yield from bps.read(oav)
+    ...         yield from bps.save()
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, log=CALLBACK_LOGGER, **kwargs)
+        self._snapshot_files: list[str] = []
+        self._microns_per_pixel: tuple[float, float]
+        self._beam_centre: tuple[int, int]
+        self._rotation_snapshot_descriptor: str = ""
+
+    def activity_gated_start(self, doc: RunStart):
+        if self.activity_uid == doc.get("uid"):
+            with_snapshot_json = doc.get("with_snapshot")  # type: ignore
+            assert with_snapshot_json, (
+                "run start event did not have expected snapshot json"
+            )
+        return doc
+
+    def activity_gated_descriptor(self, doc: EventDescriptor) -> EventDescriptor | None:
+        if doc.get("name") == DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED:
+            self._rotation_snapshot_descriptor = doc["uid"]
+        return doc
+
+    def activity_gated_event(self, doc: Event) -> Event:
+        if doc["descriptor"] == self._rotation_snapshot_descriptor:
+            self._handle_rotation_snapshot(doc)
+        return doc
+
+    def _extract_base_snapshot_params(self, doc: Event):
+        data = doc["data"]
+        self._snapshot_files.append(data["oav-snapshot-last_saved_path"])
+        self._microns_per_pixel = (
+            data["oav-microns_per_pixel_x"],
+            data["oav-microns_per_pixel_y"],
+        )
+        self._beam_centre = (data["oav-beam_centre_i"], data["oav-beam_centre_j"])
+
+    def _handle_rotation_snapshot(self, doc: Event):
+        self._extract_base_snapshot_params(doc)
+        data = doc["data"]
+        snapshot_path = data["oav-snapshot-last_saved_path"]
+        match = re.match("(.*)\\.png", snapshot_path)
+        assert match, f"Snapshot {snapshot_path} was not a .png file"
+        snapshot_base = match.groups()[0]
+        output_snapshot_path = f"{snapshot_base}_with_beam_centre.png"
+        self._generate_snapshot_at(snapshot_path, output_snapshot_path, 0, 0)
+        data["oav-snapshot-last_saved_path"] = output_snapshot_path
+        return doc
+
+    def _generate_snapshot_at(
+        self, input_snapshot_path: str, output_snapshot_path: str, x_mm: int, y_mm: int
+    ):
+        """
+        Save a snapshot to the specified path, with an annotated crosshair at the specified
+        position
+        Args:
+            input_snapshot_path: The non-annotated image path.
+            output_snapshot_path:  The path to the image that will be annotated.
+            x_mm: Relative x location of the sample to the original image (mm)
+            y_mm: Relative y location of the sample to the original image (mm)
+        """
+        image = Image.open(input_snapshot_path)
+        x_px, y_px = compute_beam_centre_pixel_xy_for_mm_position(
+            (x_mm, y_mm), self._beam_centre, self._microns_per_pixel
+        )
+        draw_crosshair(image, x_px, y_px)
+        image.save(output_snapshot_path, format="png")

mx_bluesky/hyperion/external_interaction/config_server.py

@@ -29,15 +29,15 @@ class HyperionFeatureFlags(FeatureFlags):
     def get_config_server() -> ConfigServer:
         return ConfigServer(CONST.CONFIG_SERVER_URL, LOGGER)
 
-    use_panda_for_gridscan: bool = CONST.I03.USE_PANDA_FOR_GRIDSCAN
-    compare_cpu_and_gpu_zocalo: bool = CONST.I03.COMPARE_CPU_AND_GPU_ZOCALO
-    use_gpu_results: bool = CONST.I03.USE_GPU_RESULTS
-    set_stub_offsets: bool = CONST.I03.SET_STUB_OFFSETS
-    omega_flip: bool = CONST.I03.OMEGA_FLIP
-
     @model_validator(mode="after")
     def use_gpu_and_compare_cannot_both_be_true(self):
         assert not (self.use_gpu_results and self.compare_cpu_and_gpu_zocalo), (
             "Cannot both use GPU results and compare them to CPU"
         )
         return self
+
+    use_panda_for_gridscan: bool = CONST.I03.USE_PANDA_FOR_GRIDSCAN
+    compare_cpu_and_gpu_zocalo: bool = CONST.I03.COMPARE_CPU_AND_GPU_ZOCALO
+    use_gpu_results: bool = CONST.I03.USE_GPU_RESULTS
+    set_stub_offsets: bool = CONST.I03.SET_STUB_OFFSETS
+    omega_flip: bool = CONST.I03.OMEGA_FLIP

mx_bluesky/hyperion/parameters/device_composites.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import pydantic
+from dodal.devices.aperturescatterguard import (
+    ApertureScatterguard,
+)
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.backlight import Backlight
+from dodal.devices.dcm import DCM
+from dodal.devices.eiger import EigerDetector
+from dodal.devices.fast_grid_scan import (
+    PandAFastGridScan,
+    ZebraFastGridScan,
+)
+from dodal.devices.flux import Flux
+from dodal.devices.robot import BartRobot
+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 dodal.devices.xbpm_feedback import XBPMFeedback
+from dodal.devices.zebra.zebra import Zebra
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
+from dodal.devices.zocalo import ZocaloResults
+from ophyd_async.fastcs.panda import HDFPanda
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class HyperionFlyScanXRayCentreComposite:
+    """All devices which are directly or indirectly required by this plan"""
+
+    aperture_scatterguard: ApertureScatterguard
+    attenuator: BinaryFilterAttenuator
+    backlight: Backlight
+    dcm: DCM
+    eiger: EigerDetector
+    zebra_fast_grid_scan: ZebraFastGridScan
+    flux: Flux
+    s4_slit_gaps: S4SlitGaps
+    smargon: Smargon
+    undulator: Undulator
+    synchrotron: Synchrotron
+    xbpm_feedback: XBPMFeedback
+    zebra: Zebra
+    zocalo: ZocaloResults
+    panda: HDFPanda
+    panda_fast_grid_scan: PandAFastGridScan
+    robot: BartRobot
+    sample_shutter: ZebraShutter

mx_bluesky/hyperion/parameters/gridscan.py

@@ -36,7 +36,7 @@ class GridCommonWithHyperionDetectorParams(GridCommon, WithHyperionUDCFeatures):
         return DetectorParams(
             detector_size_constants=I03Constants.DETECTOR,
             expected_energy_ev=self.demand_energy_ev,
-            exposure_time=self.exposure_time_s,
+            exposure_time_s=self.exposure_time_s,
             directory=self.storage_directory,
             prefix=self.file_name,
             detector_distance=self.detector_distance_mm,
@@ -53,7 +53,7 @@ class GridCommonWithHyperionDetectorParams(GridCommon, WithHyperionUDCFeatures):
         )
 
 
-class HyperionSpecifiedThreeDGridScan(SpecifiedThreeDGridScan, WithHyperionUDCFeatures):
+class HyperionSpecifiedThreeDGridScan(WithHyperionUDCFeatures, SpecifiedThreeDGridScan):
     """Hyperion's 3D grid scan deviates from the common class due to: optionally using a PandA, optionally using dev_shm for GPU analysis, and using a config server for features"""
 
     # These detector params only exist so that we can properly select enable_dev_shm. Remove in
@@ -73,7 +73,7 @@ class HyperionSpecifiedThreeDGridScan(SpecifiedThreeDGridScan, WithHyperionUDCFe
         return DetectorParams(
             detector_size_constants=I03Constants.DETECTOR,
             expected_energy_ev=self.demand_energy_ev,
-            exposure_time=self.exposure_time_s,
+            exposure_time_s=self.exposure_time_s,
             directory=self.storage_directory,
             prefix=self.file_name,
             detector_distance=self.detector_distance_mm,

mx_bluesky/hyperion/parameters/rotation.py

@@ -75,7 +75,7 @@ class RotationExperiment(DiffractionExperimentWithSample, WithHyperionUDCFeature
         return DetectorParams(
             detector_size_constants=I03Constants.DETECTOR,
             expected_energy_ev=self.demand_energy_ev,
-            exposure_time=self.exposure_time_s,
+            exposure_time_s=self.exposure_time_s,
             directory=self.storage_directory,
             prefix=self.file_name,
             detector_distance=self.detector_distance_mm,

mx_bluesky/hyperion/utils/__init__.py

@@ -0,0 +1 @@
+# placeholder file to start layout

mx_bluesky/hyperion/utils/context.py

@@ -1,74 +1,9 @@
-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 dodal.utils import get_beamline_based_on_environment_variable
 
 import mx_bluesky.hyperion.experiment_plans as hyperion_plans
 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)
-
 
 def setup_context(wait_for_connection: bool = True) -> BlueskyContext:
     context = BlueskyContext()

mx_bluesky/hyperion/utils/validation.py

@@ -11,8 +11,8 @@ from dodal.beamlines import i03
 from dodal.devices.oav.oav_parameters import OAVConfig
 from ophyd_async.testing import set_mock_value
 
-from mx_bluesky.hyperion.device_setup_plans.read_hardware_for_setup import (
-    read_hardware_during_collection,
+from mx_bluesky.common.plans.read_hardware import (
+    standard_read_hardware_during_collection,
 )
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
     RotationScanComposite,
@@ -67,7 +67,7 @@ def fake_rotation_scan(
         }
     )
     def plan():
-        yield from read_hardware_during_collection(
+        yield from standard_read_hardware_during_collection(
             rotation_devices.aperture_scatterguard,
             rotation_devices.attenuator,
             rotation_devices.flux,

{mx_bluesky-1.4.5.dist-info → mx_bluesky-1.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mx-bluesky
-Version: 1.4.5
+Version: 1.4.7
 Summary: Bluesky tools for MX Beamlines at DLS
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License
@@ -238,8 +238,8 @@ Requires-Dist: blueapi>=0.5.0
 Requires-Dist: daq-config-server>=0.1.1
 Requires-Dist: ophyd==1.9.0
 Requires-Dist: ophyd-async>=0.9.0a2
-Requires-Dist: bluesky>=1.13
-Requires-Dist: dls-dodal==1.40.0
+Requires-Dist: bluesky>=1.13.1
+Requires-Dist: dls-dodal==1.44.0
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -266,6 +266,7 @@ Requires-Dist: tox-direct; extra == "dev"
 Requires-Dist: tox; extra == "dev"
 Requires-Dist: types-mock; extra == "dev"
 Requires-Dist: types-requests; extra == "dev"
+Dynamic: license-file
 
 mx-bluesky
 ===========================
@@ -284,7 +285,7 @@ Releases       https://github.com/DiamondLightSource/mx-bluesky/releases
 Getting Started
 ===============
 
-To get started with developing this repo at DLS run ``dls_dev_setup.sh``.
+To get started with developing this repo at DLS run ``./utility_scripts/dls_dev_env.sh``.
 
 If you want to develop interactively at the beamline we recommend using jupyter notebooks. You can get started with this by running::