dls-dodal 1.62.0__py3-none-any.whl → 1.64.0__py3-none-any.whl

dodal/devices/i22/dcm.py

@@ -13,7 +13,7 @@ from ophyd_async.epics.motor import Motor
 
 from dodal.common.crystal_metadata import CrystalMetadata
 from dodal.devices.common_dcm import (
-    BaseDCM,
+    DoubleCrystalMonochromatorWithDSpacing,
     PitchAndRollCrystal,
     RollCrystal,
 )
@@ -23,7 +23,7 @@ from dodal.devices.common_dcm import (
 _CONVERSION_CONSTANT = 12.3984
 
 
-class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
+class DCM(DoubleCrystalMonochromatorWithDSpacing[RollCrystal, PitchAndRollCrystal]):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
 
@@ -107,7 +107,7 @@ class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
 
     async def read(self) -> dict[str, Reading]:
         default_reading = await super().read()
-        energy: float = default_reading[f"{self.name}-energy_in_kev"]["value"]
+        energy: float = default_reading[f"{self.name}-energy_in_keV"]["value"]
         if energy > 0.0:
             wavelength = _CONVERSION_CONSTANT / energy
         else:

dodal/devices/i24/dcm.py

@@ -1,13 +1,13 @@
 from ophyd_async.epics.core import epics_signal_r
 
 from dodal.devices.common_dcm import (
-    BaseDCM,
+    DoubleCrystalMonochromatorWithDSpacing,
     PitchAndRollCrystal,
     RollCrystal,
 )
 
 
-class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
+class DCM(DoubleCrystalMonochromatorWithDSpacing[RollCrystal, PitchAndRollCrystal]):
     """
     A double crystal monocromator device, used to select the beam energy.
     """

dodal/devices/oav/oav_detector.py

@@ -13,7 +13,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.areadetector.plugins.CAM import Cam
+from dodal.devices.areadetector.plugins.cam import Cam
 from dodal.devices.oav.oav_parameters import (
     DEFAULT_OAV_WINDOW,
     OAVConfig,

dodal/devices/oav/oav_parameters.py

@@ -1,9 +1,9 @@
 import json
-import xml.etree.ElementTree as et
 from abc import abstractmethod
 from collections import ChainMap
 from dataclasses import dataclass
 from typing import Any, Generic, TypeVar
+from xml.etree import ElementTree
 from xml.etree.ElementTree import Element
 
 # GDA currently assumes this aspect ratio for the OAV window size.
@@ -98,11 +98,11 @@ class OAVParameters:
         self.direction: int = update("direction", int)
         self.max_tip_distance: float = update("max_tip_distance", float, default=300)
 
-    def get_max_tip_distance_in_pixels(self, micronsPerPixel: float) -> float:
+    def get_max_tip_distance_in_pixels(self, microns_per_pixel: float) -> float:
         """
         Get the maximum tip distance in pixels.
         """
-        return self.max_tip_distance / micronsPerPixel
+        return self.max_tip_distance / microns_per_pixel
 
 
 @dataclass
@@ -123,7 +123,7 @@ class OAVConfigBase(Generic[ParamType]):
         self.zoom_params = self._get_zoom_params(zoom_params_file)
 
     def _get_zoom_params(self, zoom_params_file: str):
-        tree = et.parse(zoom_params_file)
+        tree = ElementTree.parse(zoom_params_file)
         root = tree.getroot()
         return root.findall(".//zoomLevel")
 

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -21,12 +21,12 @@ from dodal.log import LOGGER
 
 
 async def get_next_jpeg(response: ClientResponse) -> bytes:
-    JPEG_START_BYTE = b"\xff\xd8"
-    JPEG_STOP_BYTE = b"\xff\xd9"
+    jpeg_start_byte = b"\xff\xd8"
+    jpeg_stop_byte = b"\xff\xd9"
     while True:
         line = await response.content.readline()
-        if line.startswith(JPEG_START_BYTE):
-            return line + await response.content.readuntil(JPEG_STOP_BYTE)
+        if line.startswith(jpeg_start_byte):
+            return line + await response.content.readuntil(jpeg_stop_byte)
 
 
 class Source(IntEnum):

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -25,7 +25,7 @@ from dodal.log import LOGGER
 Tip = Array1D[np.int32]
 
 
-class InvalidPinException(Exception):
+class InvalidPinError(Exception):
     pass
 
 
@@ -88,7 +88,7 @@ class PinTipDetection(StandardReadable):
 
     def _set_triggered_values(self, results: SampleLocation):
         if results.tip_x is None or results.tip_y is None:
-            raise InvalidPinException
+            raise InvalidPinError
         else:
             tip = np.array([results.tip_x, results.tip_y])
             self._tip_setter(tip)
@@ -128,7 +128,7 @@ class PinTipDetection(StandardReadable):
         )
 
         start_time = time.time()
-        location = sample_detection.processArray(array_data)
+        location = sample_detection.process_array(array_data)
         end_time = time.time()
         LOGGER.debug(
             f"Sample location detection took {(end_time - start_time) * 1000.0}ms"

dodal/devices/oav/pin_image_recognition/utils.py

@@ -140,7 +140,7 @@ class MxSampleDetect:
 
         self.min_tip_height = min_tip_height
 
-    def processArray(self, arr: np.ndarray) -> SampleLocation:
+    def process_array(self, arr: np.ndarray) -> SampleLocation:
         # Get a greyscale version of the input.
         if arr.ndim == 3:
             gray_arr = cv2.cvtColor(arr, cv2.COLOR_BGR2GRAY)

dodal/devices/oav/snapshots/snapshot.py

@@ -1,6 +1,6 @@
 from PIL import Image
 
-from dodal.devices.areadetector.plugins.MJPG import MJPG
+from dodal.devices.areadetector.plugins.mjpg import MJPG
 
 CROSSHAIR_LENGTH_PX = 20
 CROSSHAIR_OUTLINE_COLOUR = "Black"

dodal/devices/oav/snapshots/snapshot_image_processing.py

@@ -16,32 +16,32 @@ def draw_crosshair(image: Image.Image, beam_x: int, beam_y: int):
         beam_y: The y-coordinate of the crosshair (pixels)
     """
     draw = ImageDraw.Draw(image)
-    OUTLINE_WIDTH = 1
-    HALF_LEN = CROSSHAIR_LENGTH_PX / 2
+    outline_width = 1
+    half_len = CROSSHAIR_LENGTH_PX / 2
     draw.rectangle(
         [
-            beam_x - OUTLINE_WIDTH,
-            beam_y - HALF_LEN - OUTLINE_WIDTH,
-            beam_x + OUTLINE_WIDTH,
-            beam_y + HALF_LEN + OUTLINE_WIDTH,
+            beam_x - outline_width,
+            beam_y - half_len - outline_width,
+            beam_x + outline_width,
+            beam_y + half_len + outline_width,
         ],
         fill=CROSSHAIR_OUTLINE_COLOUR,
     )
     draw.rectangle(
         [
-            beam_x - HALF_LEN - OUTLINE_WIDTH,
-            beam_y - OUTLINE_WIDTH,
-            beam_x + HALF_LEN + OUTLINE_WIDTH,
-            beam_y + OUTLINE_WIDTH,
+            beam_x - half_len - outline_width,
+            beam_y - outline_width,
+            beam_x + half_len + outline_width,
+            beam_y + outline_width,
         ],
         fill=CROSSHAIR_OUTLINE_COLOUR,
     )
     draw.line(
-        ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
+        ((beam_x, beam_y - half_len), (beam_x, beam_y + half_len)),
         fill=CROSSHAIR_FILL_COLOUR,
     )
     draw.line(
-        ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
+        ((beam_x - half_len, beam_y), (beam_x + half_len, beam_y)),
         fill=CROSSHAIR_FILL_COLOUR,
     )
 

dodal/devices/oav/snapshots/snapshot_with_grid.py

@@ -3,7 +3,7 @@ from os.path import join as path_join
 from ophyd_async.core import soft_signal_rw
 from PIL.Image import Image
 
-from dodal.devices.areadetector.plugins.MJPG import IMG_FORMAT, MJPG, asyncio_save_image
+from dodal.devices.areadetector.plugins.mjpg import IMG_FORMAT, MJPG, asyncio_save_image
 from dodal.devices.oav.snapshots.grid_overlay import (
     add_grid_border_overlay_to_image,
     add_grid_overlay_to_image,

dodal/devices/oav/utils.py

@@ -16,7 +16,7 @@ from dodal.devices.smargon import Smargon
 Pixel = tuple[int, int]
 
 
-class PinNotFoundException(Exception):
+class PinNotFoundError(Exception):
     pass
 
 
@@ -106,6 +106,6 @@ def wait_for_tip_to_be_found(
     found_tip = yield from bps.rd(ophyd_pin_tip_detection.triggered_tip)
     if all(found_tip == ophyd_pin_tip_detection.INVALID_POSITION):
         timeout = yield from bps.rd(ophyd_pin_tip_detection.validity_timeout)
-        raise PinNotFoundException(f"No pin found after {timeout} seconds")
+        raise PinNotFoundError(f"No pin found after {timeout} seconds")
 
     return Pixel((int(found_tip[0]), int(found_tip[1])))

dodal/devices/pgm.py

@@ -16,7 +16,7 @@ class PGM(StandardReadable):
         self,
         prefix: str,
         grating: type[StrictEnum],
-        gratingPv: str = "GRATINGSELECT:SELECT",
+        grating_pv: str = "GRATINGSELECT:SELECT",
         name: str = "",
     ) -> None:
         """
@@ -26,7 +26,7 @@ class PGM(StandardReadable):
             Beamline specific part of the PV
         grating:
             The Enum for the grating table.
-        gratingPv:
+        grating_pv:
             The suffix pv part of grating Pv
         name:
             Name of the device
@@ -34,7 +34,7 @@ class PGM(StandardReadable):
         with self.add_children_as_readables():
             self.energy = Motor(prefix + "ENERGY")
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            self.grating = epics_signal_rw(grating, prefix + gratingPv)
+            self.grating = epics_signal_rw(grating, prefix + grating_pv)
             self.cff = epics_signal_rw(float, prefix + "CFF")
 
         super().__init__(name=name)

dodal/devices/robot.py

@@ -25,7 +25,7 @@ WAIT_FOR_OLD_PIN_MSG = "Waiting on old pin unloaded"
 WAIT_FOR_NEW_PIN_MSG = "Waiting on new pin loaded"
 
 
-class RobotLoadFailed(Exception):
+class RobotLoadError(Exception):
     error_code: int
     error_string: str
 
@@ -58,7 +58,7 @@ class ErrorStatus(Device):
         error_code = await self.code.get_value()
         if error_code:
             error_string = await self.str.get_value()
-            raise RobotLoadFailed(int(error_code), error_string) from raise_from
+            raise RobotLoadError(int(error_code), error_string) from raise_from
 
 
 class BartRobot(StandardReadable, Movable[SampleLocation]):
@@ -119,12 +119,12 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
     async def pin_mounted_or_no_pin_found(self):
         """This co-routine will finish when either a pin is detected or the robot gives
         an error saying no pin was found (whichever happens first). In the case where no
-        pin was found a RobotLoadFailed error is raised.
+        pin was found a RobotLoadError error is raised.
         """
 
         async def raise_if_no_pin():
             await wait_for_value(self.prog_error.code, self.NO_PIN_ERROR_CODE, None)
-            raise RobotLoadFailed(self.NO_PIN_ERROR_CODE, "Pin was not detected")
+            raise RobotLoadError(self.NO_PIN_ERROR_CODE, "Pin was not detected")
 
         async def wfv():
             await wait_for_value(self.gonio_pin_sensor, PinMounted.PIN_MOUNTED, None)
@@ -184,4 +184,4 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         except TimeoutError as e:
             await self.prog_error.raise_if_error(e)
             await self.controller_error.raise_if_error(e)
-            raise RobotLoadFailed(0, "Robot timed out") from e
+            raise RobotLoadError(0, "Robot timed out") from e

dodal/devices/tetramm.py

@@ -24,7 +24,9 @@ from ophyd_async.epics.adcore import (
     NDFileHDFIO,
     NDPluginBaseIO,
 )
-from ophyd_async.epics.core import PvSuffix, epics_signal_r
+from ophyd_async.epics.core import PvSuffix, epics_signal_r, stop_busy_record
+
+from dodal.log import LOGGER
 
 
 class TetrammRange(StrictEnum):
@@ -110,6 +112,7 @@ class TetrammController(DetectorController):
         current_trig_status = await self.driver.trigger_mode.get_value()
 
         if current_trig_status == TetrammTrigger.FREE_RUN:  # if freerun turn off first
+            LOGGER.info("Disarming TetrAMM from free run")
             await self.disarm()
 
         # trigger mode must be set first and on its own!
@@ -144,13 +147,14 @@ class TetrammController(DetectorController):
         await wait_for_value(self._file_io.acquire, False, timeout=None)
 
     async def unstage(self):
-        await self.disarm()
-        await self._file_io.acquire.set(False)
+        LOGGER.info("Unstaging TetrAMM")
+        await self._file_io.acquire.set(False, wait=False)
 
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
-        # 2 or they will deadlock
-        await set_and_wait_for_value(self.driver.acquire, False, timeout=1)
+        # 2 or they will deadlock. Therefore must use stop_busy_record
+        LOGGER.info("Disarming TetrAMM")
+        await stop_busy_record(self.driver.acquire, False, timeout=DEFAULT_TIMEOUT)
 
     async def set_exposure(self, exposure: float) -> None:
         """Set the exposure time and acquire period.

dodal/devices/thawer.py

@@ -14,10 +14,6 @@ from ophyd_async.epics.core import epics_signal_rw
 from dodal.log import LOGGER
 
 
-class ThawingException(Exception):
-    pass
-
-
 class ThawingTimer(Device, Stoppable, Movable[float]):
     def __init__(self, control_signal: SignalRW[OnOff]) -> None:
         self._control_signal_ref = Reference(control_signal)

dodal/devices/util/lookup_tables.py

@@ -13,13 +13,19 @@ from numpy import interp, loadtxt
 from dodal.log import LOGGER
 
 
-async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
+async def energy_distance_table(
+    lookup_table_path: str,
+    comments: Sequence[str] = ["#", "Units"],
+    skiprows: int = 0,
+) -> np.ndarray:
     """
     Returns a numpy formatted lookup table for required positions of an ID gap to
     provide emission at a given beam energy.
 
     Args:
         lookup_table_path: Path to lookup table
+        comments: Lines starting with any of these strings will be ignored
+        skiprows: Number of rows to skip at the start of the file
 
     Returns:
         ndarray: Lookup table
@@ -29,7 +35,7 @@ async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
     # decodes the text
     async with aiofiles.open(lookup_table_path) as stream:
         raw_table = await stream.read()
-    return loadtxt(StringIO(raw_table), comments=["#", "Units"])
+    return loadtxt(StringIO(raw_table), comments=comments, skiprows=skiprows)
 
 
 def parse_lookup_table(filename: str) -> list[Sequence]:

dodal/devices/v2f.py

@@ -29,10 +29,10 @@ class QDV2F(StandardReadable):
         self,
         prefix: str,
         name: str = "",
-        I_suffix="I",
+        intensity_suffix="I",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            self.intensity = epics_signal_r(float, f"{prefix}{I_suffix}")
+            self.intensity = epics_signal_r(float, f"{prefix}{intensity_suffix}")
         with self.add_children_as_readables():
             self.gain = epics_signal_rw(V2FGain, f"{prefix}GAIN")
 

dodal/devices/zebra/zebra_constants_mapping.py

@@ -13,7 +13,7 @@ class ZebraMappingValidations(BaseModel):
         value = object.__getattribute__(self, name)
         if not name.startswith("__"):
             if value == -1:
-                raise UnmappedZebraException(
+                raise UnmappedZebraError(
                     f"'{type(self).__name__}.{name}' was accessed but is set to -1. Please check the zebra mappings against the zebra's physical configuration"
                 )
         return value
@@ -92,5 +92,5 @@ class ZebraMapping(ZebraMappingValidations):
     AND_GATE_FOR_AUTO_SHUTTER: int = Field(default=2, ge=-1, le=4)
 
 
-class UnmappedZebraException(Exception):
+class UnmappedZebraError(Exception):
     pass

dodal/devices/zocalo/__init__.py

@@ -1,7 +1,7 @@
 from dodal.devices.zocalo.zocalo_interaction import ZocaloStartInfo, ZocaloTrigger
 from dodal.devices.zocalo.zocalo_results import (
-    NoResultsFromZocalo,
-    NoZocaloSubscription,
+    NoResultsFromZocaloError,
+    NoZocaloSubscriptionError,
     XrcResult,
     ZocaloResults,
     ZocaloSource,
@@ -13,8 +13,8 @@ __all__ = [
     "XrcResult",
     "ZocaloTrigger",
     "get_full_processing_results",
-    "NoResultsFromZocalo",
-    "NoZocaloSubscription",
+    "NoResultsFromZocaloError",
+    "NoZocaloSubscriptionError",
     "ZocaloStartInfo",
     "ZocaloSource",
 ]

dodal/devices/zocalo/zocalo_results.py

@@ -24,11 +24,11 @@ from dodal.devices.zocalo.zocalo_interaction import _get_zocalo_connection
 from dodal.log import LOGGER
 
 
-class NoResultsFromZocalo(Exception):
+class NoResultsFromZocaloError(Exception):
     pass
 
 
-class NoZocaloSubscription(Exception):
+class NoZocaloSubscriptionError(Exception):
     pass
 
 
@@ -234,7 +234,7 @@ class ZocaloResults(StandardReadable, Triggerable):
             "meant for it"
         )
         if not self.transport:
-            raise NoZocaloSubscription(msg)
+            raise NoZocaloSubscriptionError(msg)
 
         try:
             LOGGER.info(
@@ -266,7 +266,7 @@ class ZocaloResults(StandardReadable, Triggerable):
             )
         except Empty as timeout_exception:
             LOGGER.warning("Timed out waiting for zocalo results!")
-            raise NoResultsFromZocalo(
+            raise NoResultsFromZocaloError(
                 "Timed out waiting for Zocalo results"
             ) from timeout_exception
         finally:

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

@@ -155,7 +155,7 @@ def set_mx_settings_pvs(
 
 
 if __name__ == "__main__":
-    RE = RunEngine()
+    run_engine = RunEngine()
     do_default_logging_setup()
 
     path_provider = StaticPathProvider(
@@ -166,7 +166,7 @@ if __name__ == "__main__":
     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,18 +2,18 @@ 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):
     """Verify Undulator gap is correct - it may not be after a beam dump"""
 
-    energy_in_kev = yield from bps.rd(devices.dcm.energy_in_kev.user_readback)
-    yield from bps.abs_set(devices.undulator, energy_in_kev, wait=True)
+    energy_in_keV = yield from bps.rd(devices.dcm.energy_in_keV.user_readback)  # noqa: N806
+    yield from bps.abs_set(devices.undulator, energy_in_keV, wait=True)