dls-dodal 1.61.0__py3-none-any.whl → 1.63.0__py3-none-any.whl

dodal/log.py

@@ -57,22 +57,22 @@ class CircularMemoryHandler(logging.Handler):
     """Loosely based on the MemoryHandler, which keeps a buffer and writes it when full
     or when there is a record of specific level. This instead keeps a circular buffer
     that always contains the last {capacity} number of messages, this is only flushed
-    when a log of specific {flushLevel} comes in. On flush this buffer is then passed to
+    when a log of specific {flush_level} comes in. On flush this buffer is then passed to
     the {target} handler.
 
     The CircularMemoryHandler becomes the owner of the target handler which will be closed
     on close of this handler.
     """
 
-    def __init__(self, capacity, flushLevel=logging.ERROR, target=None):
+    def __init__(self, capacity, flush_level=logging.ERROR, target=None):
         logging.Handler.__init__(self)
         self.buffer: deque[logging.LogRecord] = deque(maxlen=capacity)
-        self.flushLevel = flushLevel
+        self.flush_level = flush_level
         self.target = target
 
     def emit(self, record):
         self.buffer.append(record)
-        if record.levelno >= self.flushLevel:
+        if record.levelno >= self.flush_level:
             self.flush()
 
     def flush(self):
@@ -149,7 +149,7 @@ def set_up_graylog_handler(logger: Logger, host: str, port: int):
     return graylog_handler
 
 
-def set_up_INFO_file_handler(logger, path: Path, filename: str):
+def set_up_info_file_handler(logger, path: Path, filename: str):
     """Set up a file handler for the logger, at INFO level, which will keep 30 days
     of logs, rotating once per day. Creates the directory if necessary."""
     print(f"Logging to INFO file handler {path / filename}")
@@ -162,7 +162,7 @@ def set_up_INFO_file_handler(logger, path: Path, filename: str):
     return file_handler
 
 
-def set_up_DEBUG_memory_handler(
+def set_up_debug_memory_handler(
     logger: Logger, path: Path, filename: str, capacity: int
 ):
     """Set up a Memory handler which holds 200k lines, and writes them to an hourly
@@ -178,7 +178,7 @@ def set_up_DEBUG_memory_handler(
     file_handler.setFormatter(DEFAULT_FORMATTER)
     memory_handler = CircularMemoryHandler(
         capacity=capacity,
-        flushLevel=logging.ERROR,
+        flush_level=logging.ERROR,
         target=file_handler,
     )
     memory_handler.setLevel(logging.DEBUG)
@@ -223,8 +223,8 @@ def set_up_all_logging_handlers(
         "graylog_handler": set_up_graylog_handler(
             logger, *get_graylog_configuration(dev_mode, graylog_port)
         ),
-        "info_file_handler": set_up_INFO_file_handler(logger, logging_path, filename),
-        "debug_memory_handler": set_up_DEBUG_memory_handler(
+        "info_file_handler": set_up_info_file_handler(logger, logging_path, filename),
+        "debug_memory_handler": set_up_debug_memory_handler(
             logger, debug_logging_path or logging_path, filename, error_log_buffer_lines
         ),
     }

dodal/plan_stubs/motor_utils.py

@@ -9,7 +9,7 @@ from ophyd_async.core import Device
 from ophyd_async.epics.motor import Motor
 
 
-class MoveTooLarge(Exception):
+class MoveTooLargeError(Exception):
     def __init__(
         self,
         axis: Motor,
@@ -29,14 +29,14 @@ def check_and_cache_values(
     maximum_move: float,
 ) -> Generator[Msg, Any, dict[Motor, float]]:
     """Caches the positions of all Motors on specified device if they are within
-    smallest_move of home_position. Throws MoveTooLarge if they are outside maximum_move
+    smallest_move of home_position. Throws MoveTooLargeError if they are outside maximum_move
     of the home_position
     """
     positions = {}
     for axis, new_position in devices_and_positions.items():
         position = yield from bps.rd(axis)
         if abs(position - new_position) > maximum_move:
-            raise MoveTooLarge(axis, maximum_move, position)
+            raise MoveTooLargeError(axis, maximum_move, position)
         if abs(position - new_position) > smallest_move:
             positions[axis] = position
     return positions
@@ -68,7 +68,7 @@ def move_and_reset_wrapper(
 ) -> MsgGenerator:
     """Wrapper that does the following:
        1. Caches the positions of all Motors on device
-       2. Throws a MoveTooLarge exception if any positions are maximum_move away from home_position
+       2. Throws a MoveTooLargeError exception if any positions are maximum_move away from home_position
        2. Moves any motor that is more than smallest_move away from the home_position to home_position
        3. Runs the specified plan
        4. Moves all motors back to their cached positions

dodal/plans/configure_arm_trigger_and_disarm_detector.py

@@ -1,12 +1,18 @@
 import time
+from pathlib import PurePath
 
 import bluesky.plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.run_engine import RunEngine
-from ophyd_async.core import DetectorTrigger, TriggerInfo
+from ophyd_async.core import (
+    DetectorTrigger,
+    StaticFilenameProvider,
+    StaticPathProvider,
+    TriggerInfo,
+)
 from ophyd_async.fastcs.eiger import EigerDetector
 
-from dodal.beamlines.i03 import fastcs_eiger
+from dodal.beamlines.i03 import fastcs_eiger, set_path_provider
 from dodal.devices.detector import DetectorParams
 from dodal.log import LOGGER, do_default_logging_setup
 
@@ -28,9 +34,17 @@ def configure_arm_trigger_and_disarm_detector(
     yield from change_roi_mode(eiger, detector_params, wait=True)
     LOGGER.info(f"Changing ROI Mode: {time.time() - start}s")
     start = time.time()
-    yield from bps.abs_set(eiger.odin.num_frames_chunks, 1)
+    yield from bps.abs_set(eiger.odin.num_frames_chunks, 1, wait=True)
     LOGGER.info(f"Setting # of Frame Chunks: {time.time() - start}s")
     start = time.time()
+    yield from bps.abs_set(
+        eiger.drv.detector.photon_energy, detector_params.expected_energy_ev, wait=True
+    )
+    LOGGER.info(f"Setting Photon Energy: {time.time() - start}s")
+    start = time.time()
+    yield from bps.abs_set(eiger.drv.detector.ntrigger, 1, wait=True)
+    LOGGER.info(f"Setting Number of Triggers: {time.time() - start}s")
+    start = time.time()
     yield from set_mx_settings_pvs(eiger, detector_params, wait=True)
     LOGGER.info(f"Setting MX PVs: {time.time() - start}s")
     start = time.time()
@@ -40,7 +54,7 @@ def configure_arm_trigger_and_disarm_detector(
     yield from bps.kickoff(eiger, wait=True)
     LOGGER.info(f"Kickoff Eiger: {time.time() - start}s")
     start = time.time()
-    yield from bps.trigger(eiger.drv.detector.trigger)  # type: ignore
+    yield from bps.trigger(eiger.drv.detector.trigger, wait=True)
     LOGGER.info(f"Triggering Eiger: {time.time() - start}s")
     start = time.time()
     yield from bps.complete(eiger, wait=True)
@@ -82,7 +96,7 @@ def change_roi_mode(
 
     yield from bps.abs_set(
         eiger.drv.detector.roi_mode,
-        1 if detector_params.use_roi_mode else 0,
+        "4M" if detector_params.use_roi_mode else "disabled",
         group=group,
     )
     yield from bps.abs_set(
@@ -141,10 +155,18 @@ def set_mx_settings_pvs(
 
 
 if __name__ == "__main__":
-    RE = RunEngine()
+    run_engine = RunEngine()
     do_default_logging_setup()
+
+    path_provider = StaticPathProvider(
+        StaticFilenameProvider("eiger_test_file12.h5"),
+        PurePath("/dls/i03/data/2025/cm40607-2/test_new_eiger/"),
+    )
+
+    set_path_provider(path_provider)
+
     eiger = fastcs_eiger(connect_immediately=True)
-    RE(
+    run_engine(
         configure_arm_trigger_and_disarm_detector(
             eiger=eiger,
             detector_params=DetectorParams(

dodal/plans/save_panda.py

@@ -15,7 +15,7 @@ from dodal.beamlines import module_name_for_beamline
 from dodal.utils import make_device
 
 
-def main(argv: list[str]):
+def main(argv: list[str] | None = None):
     """CLI Utility to save the panda configuration."""
     parser = ArgumentParser(description="Save an ophyd_async panda to yaml")
     parser.add_argument(
@@ -39,7 +39,7 @@ def main(argv: list[str]):
     )
 
     # this exit()s with message/help unless args parsed successfully
-    args = parser.parse_args(argv[1:])
+    args = parser.parse_args(argv)
 
     beamline = args.beamline
     device_name = args.device_name
@@ -71,7 +71,7 @@ def main(argv: list[str]):
 
 
 def _save_panda(beamline, device_name, output_directory, file_name):
-    RE = RunEngine()
+    run_engine = RunEngine()
     print("Creating devices...")
     module_name = module_name_for_beamline(beamline)
     try:
@@ -86,18 +86,18 @@ def _save_panda(beamline, device_name, output_directory, file_name):
     print(
         f"Saving to {output_directory}/{file_name} from {device_name} on {beamline}..."
     )
-    _save_panda_to_yaml(RE, cast(Device, panda), file_name, output_directory)
+    _save_panda_to_yaml(run_engine, cast(Device, panda), file_name, output_directory)
 
 
 def _save_panda_to_yaml(
-    RE: RunEngine, panda: Device, file_name: str, output_directory: str
+    run_engine: RunEngine, panda: Device, file_name: str, output_directory: str
 ):
     def save_to_file():
         provider = YamlSettingsProvider(output_directory)
         yield from store_settings(provider, file_name, panda)
 
-    RE(save_to_file())
+    run_engine(save_to_file())
 
 
 if __name__ == "__main__":  # pragma: no cover
-    sys.exit(main(sys.argv))
+    sys.exit(main(sys.argv[1:]))

dodal/plans/verify_undulator_gap.py

@@ -2,14 +2,14 @@ from typing import Protocol, runtime_checkable
 
 from bluesky import plan_stubs as bps
 
-from dodal.devices.common_dcm import BaseDCM
+from dodal.devices.common_dcm import DoubleCrystalMonochromatorBase
 from dodal.devices.undulator import Undulator
 
 
 @runtime_checkable
 class CheckUndulatorDevices(Protocol):
     undulator: Undulator
-    dcm: BaseDCM
+    dcm: DoubleCrystalMonochromatorBase
 
 
 def verify_undulator_gap(devices: CheckUndulatorDevices):

dls_dodal-1.61.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-dodal = dodal.__main__:main
-save-panda = dodal.devices.util.save_panda:main

dodal/beamlines/i10-1.py

@@ -1,25 +0,0 @@
-from dodal.common.beamlines.beamline_utils import (
-    device_factory,
-)
-from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.synchrotron import Synchrotron
-from dodal.devices.temperture_controller import Lakeshore336
-from dodal.log import set_beamline as set_log_beamline
-from dodal.utils import BeamlinePrefix, get_beamline_name
-
-BL = get_beamline_name("i10-1")
-PREFIX = BeamlinePrefix(BL, suffix="J")
-set_log_beamline(BL)
-set_utils_beamline(BL)
-
-
-@device_factory()
-def synchrotron() -> Synchrotron:
-    return Synchrotron()
-
-
-@device_factory()
-def em_temperature_controller() -> Lakeshore336:
-    return Lakeshore336(
-        prefix=f"{PREFIX.beamline_prefix}-EA-TCTRL-41:",
-    )

dodal/devices/i09/dcm.py

@@ -1,26 +0,0 @@
-from ophyd_async.core import derived_signal_r
-
-from dodal.devices.common_dcm import BaseDCM, PitchAndRollCrystal, StationaryCrystal
-
-
-class DCM(BaseDCM[PitchAndRollCrystal, StationaryCrystal]):
-    """
-    I09 double crystal monochromator (DCM), used to select the energy of the beam.
-    Differences:
-
-    1. Can provide energy in eV via dcm.energy_in_ev read signal
-
-    This DCM is available on i09 and i09_1 endstations.
-    """
-
-    def __init__(self, prefix: str, name: str = "") -> None:
-        super().__init__(prefix, PitchAndRollCrystal, StationaryCrystal, name)
-        self.energy_in_ev = derived_signal_r(
-            self._convert_keV_to_eV, energy_signal=self.energy_in_kev.user_readback
-        )
-        # Set name so that new child signals get correct name
-        # need to do it until https://github.com/bluesky/ophyd-async/pull/899 merged
-        self.set_name(self.name)
-
-    def _convert_keV_to_eV(self, energy_signal: float) -> float:
-        return energy_signal * 1000