mx-bluesky 1.2.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

mx_bluesky/beamlines/i24/serial/setup_beamline/setup_zebra_plans.py

@@ -9,8 +9,6 @@ the edm screen, while on the schematics they are 0 indexed. Thus, `Soft In 1` fr
 schematics corresponds to soft_in_2 in the code.
 """
 
-import logging
-
 import bluesky.plan_stubs as bps
 from dodal.devices.zebra import (
     AND3,
@@ -35,6 +33,8 @@ from dodal.devices.zebra import (
     Zebra,
 )
 
+from mx_bluesky.beamlines.i24.serial.log import SSX_LOGGER
+
 # Detector specific outs
 TTL_EIGER = 1
 TTL_PILATUS = 2
@@ -48,8 +48,6 @@ SHUTTER_MODE = {
 GATE_START = 1.0
 SHUTTER_OPEN_TIME = 0.05  # For pp with long delays
 
-logger = logging.getLogger("I24ssx.setup_zebra")
-
 
 def get_zebra_settings_for_extruder(
     exp_time: float,
@@ -70,29 +68,29 @@ def get_zebra_settings_for_extruder(
 
 
 def arm_zebra(zebra: Zebra):
-    yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)
-    logger.info("Zebra armed.")
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    SSX_LOGGER.info("Zebra armed.")
 
 
 def disarm_zebra(zebra: Zebra):
-    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, wait=True)
-    logger.info("Zebra disarmed.")
+    yield from bps.abs_set(zebra.pc.arm, ArmDemand.DISARM, wait=True)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    SSX_LOGGER.info("Zebra disarmed.")
 
 
 def open_fast_shutter(zebra: Zebra):
     yield from bps.abs_set(zebra.inputs.soft_in_2, SoftInState.YES, wait=True)
-    logger.info("Fast shutter open.")
+    SSX_LOGGER.info("Fast shutter open.")
 
 
 def close_fast_shutter(zebra: Zebra):
     yield from bps.abs_set(zebra.inputs.soft_in_2, SoftInState.NO, wait=True)
-    logger.info("Fast shutter closed.")
+    SSX_LOGGER.info("Fast shutter closed.")
 
 
 def set_shutter_mode(zebra: Zebra, mode: str):
     # SOFT_IN:B0 has to be disabled for manual mode
     yield from bps.abs_set(zebra.inputs.soft_in_1, SHUTTER_MODE[mode], wait=True)
-    logger.info(f"Shutter mode set to {mode}.")
+    SSX_LOGGER.info(f"Shutter mode set to {mode}.")
 
 
 def setup_pc_sources(
@@ -124,12 +122,12 @@ def setup_zebra_for_quickshot_plan(
         exp_time (float): Collection exposure time, in s.
         num_images (float): Number of images to be collected.
     """
-    logger.info("Setup ZEBRA for quickshot collection.")
+    SSX_LOGGER.info("Setup ZEBRA for quickshot collection.")
     yield from bps.abs_set(zebra.pc.arm_source, ArmSource.SOFT, group=group)
     yield from setup_pc_sources(zebra, TrigSource.TIME, TrigSource.EXTERNAL)
 
     gate_width = exp_time * num_images + 0.5
-    logger.info(f"Gate start set to {GATE_START}, with width {gate_width}.")
+    SSX_LOGGER.info(f"Gate start set to {GATE_START}, with width {gate_width}.")
     yield from bps.abs_set(zebra.pc.gate_start, GATE_START, group=group)
     yield from bps.abs_set(zebra.pc.gate_width, gate_width, group=group)
 
@@ -138,7 +136,7 @@ def setup_zebra_for_quickshot_plan(
 
     if wait:
         yield from bps.wait(group)
-    logger.info("Finished setting up zebra.")
+    SSX_LOGGER.info("Finished setting up zebra.")
 
 
 def set_logic_gates_for_porto_triggering(
@@ -204,7 +202,7 @@ def setup_zebra_for_extruder_with_pump_probe_plan(
         pulse1_delay (float, optional): Delay to start pulse1 (the laser control) after \
             gate start. Defaults to 0.0.
     """
-    logger.info("Setup ZEBRA for pump probe extruder collection.")
+    SSX_LOGGER.info("Setup ZEBRA for pump probe extruder collection.")
 
     yield from set_shutter_mode(zebra, "manual")
 
@@ -226,7 +224,7 @@ def setup_zebra_for_extruder_with_pump_probe_plan(
     gate_width, gate_step = get_zebra_settings_for_extruder(
         exp_time, pump_exp, pump_delay
     )
-    logger.info(
+    SSX_LOGGER.info(
         f"""
         Gate start set to {GATE_START}, with calculated width {gate_width}
         and step {gate_step}.
@@ -241,13 +239,13 @@ def setup_zebra_for_extruder_with_pump_probe_plan(
     # Settings for extruder pump probe:
     # PULSE1_DLY is the start (0 usually), PULSE1_WID is the laser dwell set on edm
     # PULSE2_DLY is the laser delay set on edm, PULSE2_WID is the exposure time
-    logger.info(
+    SSX_LOGGER.info(
         f"Pulse1 starting at {pulse1_delay} with width set to laser dwell {pump_exp}."
     )
     yield from bps.abs_set(zebra.output.pulse_1.input, PC_GATE, group=group)
     yield from bps.abs_set(zebra.output.pulse_1.delay, pulse1_delay, group=group)
     yield from bps.abs_set(zebra.output.pulse_1.width, pump_exp, group=group)
-    logger.info(
+    SSX_LOGGER.info(
         f"""
         Pulse2 starting at laser delay {pump_delay} with width set to \
         exposure time {exp_time}.
@@ -259,7 +257,7 @@ def setup_zebra_for_extruder_with_pump_probe_plan(
 
     if wait:
         yield from bps.wait(group)
-    logger.info("Finished setting up zebra.")
+    SSX_LOGGER.info("Finished setting up zebra.")
 
 
 def setup_zebra_for_fastchip_plan(
@@ -302,7 +300,7 @@ def setup_zebra_for_fastchip_plan(
         start_time_offset (float): Delay on the start of the position compare. \
             Defaults to 0.0 (standard chip collection).
     """
-    logger.info("Setup ZEBRA for a fixed target collection.")
+    SSX_LOGGER.info("Setup ZEBRA for a fixed target collection.")
 
     yield from set_shutter_mode(zebra, "manual")
 
@@ -341,7 +339,7 @@ def setup_zebra_for_fastchip_plan(
 
     if wait:
         yield from bps.wait(group)
-    logger.info("Finished setting up zebra.")
+    SSX_LOGGER.info("Finished setting up zebra.")
 
 
 def open_fast_shutter_at_each_position_plan(
@@ -371,10 +369,10 @@ def open_fast_shutter_at_each_position_plan(
         num_exposures (int): Number of times data is collected in each aperture.
         exposure_time (float): Exposure time for each shot.
     """
-    logger.info(
+    SSX_LOGGER.info(
         "ZEBRA setup for fastchip collection with long delays between exposures."
     )
-    logger.debug("Controlling the fast shutter on PULSE2.")
+    SSX_LOGGER.debug("Controlling the fast shutter on PULSE2.")
     # Output panel pulse_2 settings
     yield from bps.abs_set(zebra.output.pulse_2.input, PC_GATE, group=group)
     yield from bps.abs_set(zebra.output.pulse_2.delay, 0.0, group=group)
@@ -386,7 +384,7 @@ def open_fast_shutter_at_each_position_plan(
 
     if wait:
         yield from bps.wait(group=group)
-    logger.debug("Finished setting up for long delays.")
+    SSX_LOGGER.debug("Finished setting up for long delays.")
 
 
 def reset_pc_gate_and_pulse(zebra: Zebra, group: str = "reset_pc"):
@@ -444,16 +442,16 @@ def zebra_return_to_normal_plan(
 
     if wait:
         yield from bps.wait(group)
-    logger.info("Zebra settings back to normal.")
+    SSX_LOGGER.info("Zebra settings back to normal.")
 
 
 def reset_zebra_when_collection_done_plan(zebra: Zebra):
     """
     End of collection zebra operations: close fast shutter, disarm and reset settings.
     """
-    logger.debug("Close the fast shutter.")
+    SSX_LOGGER.debug("Close the fast shutter.")
     yield from close_fast_shutter(zebra)
-    logger.debug("Disarm the zebra.")
+    SSX_LOGGER.debug("Disarm the zebra.")
     yield from disarm_zebra(zebra)
-    logger.debug("Set zebra back to normal.")
+    SSX_LOGGER.debug("Set zebra back to normal.")
     yield from zebra_return_to_normal_plan(zebra, wait=True)

mx_bluesky/beamlines/i24/serial/write_nexus.py

@@ -1,105 +1,107 @@
-import logging
 import os
 import pathlib
 import pprint
 import time
 from datetime import datetime
-from typing import Literal
 
 import requests
 
 from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import ChipType, MappingType
+from mx_bluesky.beamlines.i24.serial.log import SSX_LOGGER
 from mx_bluesky.beamlines.i24.serial.parameters import (
     ExtruderParameters,
     FixedTargetParameters,
 )
-from mx_bluesky.beamlines.i24.serial.setup_beamline import Eiger, caget, cagetstring
-
-logger = logging.getLogger("I24ssx.nexus_writer")
+from mx_bluesky.beamlines.i24.serial.setup_beamline import Eiger, caget
 
 
 def call_nexgen(
     chip_prog_dict: dict | None,
-    start_time: datetime,
     parameters: ExtruderParameters | FixedTargetParameters,
-    wavelength: float,
-    expt_type: Literal["fixed-target", "extruder"] = "fixed-target",
+    wavelength_in_a: float,
+    beam_center_in_pix: tuple[float, float],
+    start_time: datetime | None = None,
 ):
-    det_type = parameters.detector_name
-    print(f"det_type: {det_type}")
+    """Call the nexus writer by sending a request to nexgen-server.
+
+    Args:
+        chip_prog_dict (dict | None): Dictionary containing most of the information \
+            passed to the program runner for the collection. Only used for fixed target.
+        start_time
+        parameters (SerialAndLaserExperiment): Collection parameters.
+        wavelength_in_a (float): Wavelength, in A.
+        beam_center_in_pix (list[float]): Beam center position on detector, in pixels.
+        start_time (datetime, optional): Collection start time.
+
+    Raises:
+        ValueError: For a wrong experiment type passed (either unknwon or not matched \
+            to parameter model).
 
+    """
     current_chip_map = None
-    if expt_type == "fixed-target" and isinstance(parameters, FixedTargetParameters):
-        if not (
-            parameters.map_type == MappingType.NoMap
-            or parameters.chip.chip_type == ChipType.Custom
-        ):
-            # NOTE Nexgen server is still on nexgen v0.7.2 (fully working for ssx)
-            # Will need to be updated, for correctness sake map needs to be None.
-            current_chip_map = "/dls_sw/i24/scripts/fastchips/litemaps/currentchip.map"
-        pump_status = bool(parameters.pump_repeat)
-        total_numb_imgs = parameters.total_num_images
-    elif expt_type == "extruder" and isinstance(parameters, ExtruderParameters):
-        # chip_prog_dict should be None for extruder (passed as input for now)
-        total_numb_imgs = parameters.num_images
-        pump_status = parameters.pump_status
-    else:
-        raise ValueError(f"{expt_type=} not recognised")
+    match parameters:
+        case FixedTargetParameters():
+            if not (
+                parameters.map_type == MappingType.NoMap
+                or parameters.chip.chip_type == ChipType.Custom
+            ):
+                # NOTE Nexgen server is still on nexgen v0.7.2 (fully working for ssx)
+                # Will need to be updated, for correctness sake map needs to be None.
+                current_chip_map = (
+                    "/dls_sw/i24/scripts/fastchips/litemaps/currentchip.map"
+                )
+            pump_status = bool(parameters.pump_repeat)
+            total_numb_imgs = parameters.total_num_images
+        case ExtruderParameters():
+            total_numb_imgs = parameters.num_images
+            pump_status = parameters.pump_status
 
-    filename_prefix = cagetstring(Eiger.pv.filenameRBV)
-    meta_h5 = (
-        pathlib.Path(parameters.visit)
-        / parameters.directory
-        / f"{filename_prefix}_meta.h5"
-    )
+    filename_prefix = parameters.filename
+    meta_h5 = parameters.visit / parameters.directory / f"{filename_prefix}_meta.h5"
     t0 = time.time()
     max_wait = 60  # seconds
-    logger.info(f"Watching for {meta_h5}")
+    SSX_LOGGER.info(f"Watching for {meta_h5}")
     while time.time() - t0 < max_wait:
         if meta_h5.exists():
-            logger.info(f"Found {meta_h5} after {time.time() - t0:.1f} seconds")
+            SSX_LOGGER.info(f"Found {meta_h5} after {time.time() - t0:.1f} seconds")
             time.sleep(5)
             break
-        logger.debug(f"Waiting for {meta_h5}")
+        SSX_LOGGER.debug(f"Waiting for {meta_h5}")
         time.sleep(1)
     if not meta_h5.exists():
-        logger.warning(f"Giving up waiting for {meta_h5} after {max_wait} seconds")
-        return False
-
-    transmission = (float(caget(Eiger.pv.transmission)),)
+        SSX_LOGGER.warning(f"Giving up waiting for {meta_h5} after {max_wait} seconds")
+        return
 
-    if det_type == Eiger.name:
-        bit_depth = int(caget(Eiger.pv.bit_depth))
-        logger.debug(
-            f"Call to nexgen server with the following chip definition: \n{chip_prog_dict}"
-        )
+    bit_depth = int(caget(Eiger.pv.bit_depth))
+    SSX_LOGGER.debug(
+        f"Call to nexgen server with the following chip definition: \n{chip_prog_dict}"
+    )
 
-        access_token = pathlib.Path("/scratch/ssx_nexgen.key").read_text().strip()
-        url = "https://ssx-nexgen.diamond.ac.uk/ssx_eiger/write"
-        headers = {"Authorization": f"Bearer {access_token}"}
+    access_token = pathlib.Path("/scratch/ssx_nexgen.key").read_text().strip()
+    url = "https://ssx-nexgen.diamond.ac.uk/ssx_eiger/write"
+    headers = {"Authorization": f"Bearer {access_token}"}
 
-        payload = {
-            "beamline": "i24",
-            "beam_center": [caget(Eiger.pv.beamx), caget(Eiger.pv.beamy)],
-            "chipmap": current_chip_map,
-            "chip_info": chip_prog_dict,
-            "det_dist": parameters.detector_distance_mm,
-            "exp_time": parameters.exposure_time_s,
-            "expt_type": expt_type,
-            "filename": filename_prefix,
-            "num_imgs": total_numb_imgs,
-            "pump_status": pump_status,
-            "pump_exp": parameters.laser_dwell_s,
-            "pump_delay": parameters.laser_delay_s,
-            "transmission": transmission[0],
-            "visitpath": os.fspath(meta_h5.parent),
-            "wavelength": wavelength,
-            "bit_depth": bit_depth,
-        }
-        logger.info(f"Sending POST request to {url} with payload:")
-        logger.info(pprint.pformat(payload))
-        response = requests.post(url, headers=headers, json=payload)
-        logger.info(f"Response: {response.text} (status code: {response.status_code})")
-        # the following will raise an error if the request was unsuccessful
-        return response.status_code == requests.codes.ok
-    return False
+    payload = {
+        "beamline": "i24",
+        "beam_center": beam_center_in_pix,
+        "chipmap": current_chip_map,
+        "chip_info": chip_prog_dict,
+        "det_dist": parameters.detector_distance_mm,
+        "exp_time": parameters.exposure_time_s,
+        "expt_type": parameters.nexgen_experiment_type,
+        "filename": filename_prefix,
+        "num_imgs": total_numb_imgs,
+        "pump_status": pump_status,
+        "pump_exp": parameters.laser_dwell_s,
+        "pump_delay": parameters.laser_delay_s,
+        "transmission": parameters.transmission,
+        "visitpath": os.fspath(meta_h5.parent),
+        "wavelength": wavelength_in_a,
+        "bit_depth": bit_depth,
+        "start_time": start_time,
+    }
+    SSX_LOGGER.info(f"Sending POST request to {url} with payload:")
+    SSX_LOGGER.info(pprint.pformat(payload))
+    response = requests.post(url, headers=headers, json=payload)
+    response.raise_for_status()
+    SSX_LOGGER.info(f"Response: {response.text} (status code: {response.status_code})")

mx_bluesky/common/device_setup_plans/read_hardware_for_setup.py

@@ -0,0 +1,14 @@
+import bluesky.plan_stubs as bps
+from dodal.devices.eiger import EigerDetector
+
+from mx_bluesky.common.parameters.constants import DocDescriptorNames
+
+
+def read_hardware_for_zocalo(detector: EigerDetector):
+    """ "
+    If the RunEngine is subscribed to the ZocaloCallback, this plan will also trigger zocalo.
+    A bluesky run must be open to use this plan
+    """
+    yield from bps.create(name=DocDescriptorNames.ZOCALO_HW_READ)
+    yield from bps.read(detector.odin.file_writer.id)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.save()

mx_bluesky/common/external_interaction/config_server.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from functools import cache
+
+from daq_config_server.client import ConfigServer
+from pydantic import BaseModel, Field, model_validator
+
+
+class FeatureFlags(BaseModel, ABC):
+    """Abstract class to use ConfigServer to toggle features for an experiment
+
+    A module wanting to use FeatureFlags should inherit this class, add boolean features
+    as attributes, and implement a get_config_server method, which returns a cached creation of
+    ConfigServer. See HyperionFeatureFlags for an example
+
+    Values supplied upon class instantiation will always take priority over the config server. If connection to the server cannot
+    be made AND values were not supplied, attributes will use their default values
+    """
+
+    # Feature values supplied at construction will override values from the config server
+    overriden_features: dict = Field(default_factory=dict, exclude=True)
+
+    @staticmethod
+    @cache
+    @abstractmethod
+    def get_config_server() -> ConfigServer: ...
+
+    @model_validator(mode="before")
+    @classmethod
+    def mark_overridden_features(cls, values):
+        assert isinstance(values, dict)
+        values["overriden_features"] = values.copy()
+        return values
+
+    def _get_flags(self):
+        flags = type(self).get_config_server().best_effort_get_all_feature_flags()
+        return {f: flags[f] for f in flags if f in self.model_fields.keys()}
+
+    def update_self_from_server(self):
+        """Used to update the feature flags from the server during a plan. Where there are flags which were explicitly set from externally supplied parameters, these values will be used instead."""
+        for flag, value in self._get_flags().items():
+            updated_value = (
+                value
+                if flag not in self.overriden_features.keys()
+                else self.overriden_features[flag]
+            )
+            setattr(self, flag, updated_value)