dls-dodal 1.69.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

dodal/devices/areadetector/plugins/mjpg.py

@@ -25,7 +25,8 @@ class MJPG(StandardReadable, Triggerable, ABC):
     """The MJPG areadetector plugin creates an MJPG video stream of the camera's output.
 
     This devices uses that stream to grab images. When it is triggered it will send the
-    latest image from the stream to the `post_processing` method for child classes to handle.
+    latest image from the stream to the `post_processing` method for child classes to
+    handle.
     """
 
     def __init__(
@@ -51,9 +52,9 @@ class MJPG(StandardReadable, Triggerable, ABC):
         super().__init__(name)
 
     async def _save_image(self, image: Image.Image):
-        """A helper function to save a given image to the path supplied by the \
-            directory and filename signals. The full resultant path is put on the \
-            last_saved_path signal
+        """A helper function to save a given image to the path supplied by the
+        directory and filename signals. The full resultant path is put on the
+        last_saved_path signal.
         """
         filename_str = await self.filename.get_value()
         directory_str = await self.directory.get_value()
@@ -74,7 +75,7 @@ class MJPG(StandardReadable, Triggerable, ABC):
         """This takes a snapshot image from the MJPG stream and send it to the
         post_processing method, expected to be implemented by a child of this class.
 
-        It is the responsibility of the child class to save any resulting images by \
+        It is the responsibility of the child class to save any resulting images by
         calling _save_image.
         """
         url_str = await self.url.get_value()

dodal/devices/attenuator/attenuator.py

@@ -37,13 +37,15 @@ class ReadOnlyAttenuator(StandardReadable):
 
 class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     """The attenuator will insert filters into the beam to reduce its transmission.
-    In this attenuator, each filter can be in one of two states: IN or OUT
+    In this attenuator, each filter can be in one of two states: IN or OUT.
 
     This device should be set with:
+
         yield from bps.set(attenuator, desired_transmission)
 
     Where desired_transmission is fraction e.g. 0-1. When the actual_transmission is
-    read from the device it is also fractional"""
+    read from the device it is also fractional
+    """
 
     def __init__(self, prefix: str, num_filters: int, name: str = ""):
         self._calculated_filter_states: DeviceVector[SignalR[int]] = DeviceVector(
@@ -72,11 +74,10 @@ class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     async def set(self, value: float):
         """Set the transmission to the fractional (0-1) value given.
 
-        The attenuator IOC will then insert filters to reach the desired transmission for
-        the current beamline energy, the set will only complete when they have all been
-        applied.
+        The attenuator IOC will then insert filters to reach the desired transmission
+        for the current beamline energy, the set will only complete when they have all
+        been applied.
         """
-
         LOGGER.debug("Using current energy ")
         await self._use_current_energy.trigger()
         LOGGER.info(f"Setting desired transmission to {value}")
@@ -110,7 +111,8 @@ ENUM_ATTENUATOR_SETTLE_TIME_S = 0.15
 class EnumFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     """The attenuator will insert filters into the beam to reduce its transmission.
 
-    This device is currently working, but feature incomplete. See https://github.com/DiamondLightSource/dodal/issues/972
+    This device is currently working, but feature incomplete. See
+    https://github.com/DiamondLightSource/dodal/issues/972
 
     In this attenuator, the state of a filter corresponds to the selected material,
     e.g Ag50, in contrast to being either 'IN' or 'OUT'; see BinaryFilterAttenuator.
@@ -141,11 +143,10 @@ class EnumFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     async def set(self, value: float):
         """Set the transmission to the fractional (0-1) value given.
 
-        The attenuator IOC will then insert filters to reach the desired transmission for
-        the current beamline energy, the set will only complete when they have all been
-        applied.
+        The attenuator IOC will then insert filters to reach the desired transmission
+        for the current beamline energy, the set will only complete when they have all
+        been applied.
         """
-
         # auto move should normally be on, but check here incase it was manually turned off
         await self._auto_move_on_desired_transmission_set.set(YesNo.YES)
 

dodal/devices/beamlines/b07/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.beamlines.b07.enums import Grating, LensMode, PsuMode
+
+__all__ = ["Grating", "LensMode", "PsuMode"]

dodal/devices/{b07_1 → beamlines/b07_1}/__init__.py

@@ -1,8 +1,8 @@
-from dodal.devices.b07_1.ccmc import (
+from dodal.devices.beamlines.b07_1.ccmc import (
     ChannelCutMonochromator,
     ChannelCutMonochromatorPositions,
 )
-from dodal.devices.b07_1.enums import Grating, LensMode
+from dodal.devices.beamlines.b07_1.enums import Grating, LensMode
 
 __all__ = [
     "Grating",

dodal/devices/{b07_1 → beamlines/b07_1}/ccmc.py

@@ -25,13 +25,16 @@ error_message = "Can not get energy value in eV from ccmc position: "
 class ChannelCutMonochromator(
     StandardReadable, Movable[ChannelCutMonochromatorPositions]
 ):
-    """
-    Device to move the channel cut monochromator (ccmc). CCMC has three
+    """Device to move the channel cut monochromator (ccmc). CCMC has three
     choices of crystal (Xtal for short). Setting energy is by means of a
     multi-positioner. The positions are named after the nominal energies of the
     crystals. To change energy select one of the crystals from the list.
     This causes the Y motor to move that crystal into the beam and other
     motors have to align the angles correctly.
+
+    Args:
+        prefix (str): Beamline specific part of the PV.
+        name (str, optional): Name of the device.
     """
 
     def __init__(
@@ -39,14 +42,6 @@ class ChannelCutMonochromator(
         prefix: str,
         name: str = "",
     ) -> None:
-        """
-        Parameters
-        ----------
-        prefix:
-            Beamline specific part of the PV
-        name:
-            Name of the device
-        """
         with self.add_children_as_readables():
             # crystal motors
             self._xyz = XYZStage(prefix)

dodal/devices/{b16 → beamlines/b16}/detector.py

@@ -10,10 +10,9 @@ from dodal.devices.controllers import ConstantDeadTimeController
 
 
 def software_triggered_tiff_area_detector(prefix: str, deadtime: float = 0.0):
-    """
-    Wrapper for AreaDetector with fixed dead time (defaulted to 0)
+    """Wrapper for AreaDetector with fixed dead time (defaulted to 0)
     and a TIFF file writer.
-    Most detectors in B16 could be configured like this
+    Most detectors in B16 could be configured like this.
     """
     return AreaDetector(
         writer=ADTIFFWriter.with_io(

dodal/devices/{i02_1 → beamlines/i02_1}/fast_grid_scan.py

@@ -11,8 +11,7 @@ from dodal.log import LOGGER
 
 
 class ZebraGridScanParamsTwoD(GridScanParamsCommon, WithDwellTime):
-    """
-    Params for 2D Zebra FGS. Adds on the dwell time, which is really the time
+    """Params for 2D Zebra FGS. Adds on the dwell time, which is really the time
     between trigger positions.
     """
 
@@ -23,7 +22,7 @@ class ZebraFastGridScanTwoD(FastGridScanCommon[ZebraGridScanParamsTwoD]):
     - No Z steps, Z step sizes, or Y2 start positions, or Z2 start
     - No scan valid PV - see https://github.com/DiamondLightSource/mx-bluesky/issues/1203
     - No program_number - see https://github.com/DiamondLightSource/mx-bluesky/issues/1203
-    """
+    """  # noqa D415
 
     def __init__(
         self, prefix: str, motion_controller_prefix: str, name: str = ""

dodal/devices/{i02_1 → beamlines/i02_1}/sample_motors.py

@@ -3,7 +3,7 @@ from ophyd_async.epics.motor import Motor
 
 
 class SampleMotors(StandardReadable):
-    """Virtual Smaract motors on i02-1 (VMXm)"""
+    """Virtual Smaract motors on i02-1 (VMXm)."""
 
     def __init__(
         self,

dodal/devices/{i03 → beamlines/i03}/beamsize.py

@@ -1,11 +1,15 @@
 from ophyd_async.core import Reference, derived_signal_r
 
 from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.beamlines.i03.constants import BeamsizeConstants
 from dodal.devices.beamsize.beamsize import BeamsizeBase
-from dodal.devices.i03.constants import BeamsizeConstants
 
 
 class Beamsize(BeamsizeBase):
+    """Device that calculates the size of the beam by taking the minimum of the beam
+    dimensions and the aperture scatterguard diameter.
+    """
+
     def __init__(self, aperture_scatterguard: ApertureScatterguard, name=""):
         super().__init__(name=name)
         self._aperture_scatterguard_ref = Reference(aperture_scatterguard)
@@ -13,23 +17,23 @@ class Beamsize(BeamsizeBase):
         with self.add_children_as_readables():
             self.x_um = derived_signal_r(
                 self._get_beamsize_x,
-                aperture_radius=self._aperture_scatterguard_ref().radius,
+                aperture_diameter=self._aperture_scatterguard_ref().diameter,
                 derived_units="µm",
             )
             self.y_um = derived_signal_r(
                 self._get_beamsize_y,
-                aperture_radius=self._aperture_scatterguard_ref().radius,
+                aperture_diameter=self._aperture_scatterguard_ref().diameter,
                 derived_units="µm",
             )
 
     def _get_beamsize_x(
         self,
-        aperture_radius: float,
+        aperture_diameter: float,
     ) -> float:
-        return min(aperture_radius, BeamsizeConstants.BEAM_WIDTH_UM)
+        return min(aperture_diameter, BeamsizeConstants.BEAM_WIDTH_UM)
 
     def _get_beamsize_y(
         self,
-        aperture_radius: float,
+        aperture_diameter: float,
     ) -> float:
-        return min(aperture_radius, BeamsizeConstants.BEAM_HEIGHT_UM)
+        return min(aperture_diameter, BeamsizeConstants.BEAM_HEIGHT_UM)

dodal/devices/{i03 → beamlines/i03}/dcm.py

@@ -18,8 +18,7 @@ from dodal.devices.common_dcm import (
 class DCM(
     DoubleCrystalMonochromatorWithDSpacing[PitchAndRollCrystal, StationaryCrystal]
 ):
-    """
-    A double crystal monochromator (DCM), used to select the energy of the beam.
+    """A double crystal monochromator (DCM), used to select the energy of the beam.
 
     perp describes the gap between the 2 DCM crystals which has to change as you alter
     the angle to select the requested energy.

dodal/devices/{i03 → beamlines/i03}/undulator_dcm.py

@@ -4,7 +4,7 @@ from bluesky.protocols import Movable
 from ophyd_async.core import AsyncStatus, Reference, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
-from dodal.devices.i03.dcm import DCM
+from dodal.devices.beamlines.i03.dcm import DCM
 from dodal.devices.undulator import UndulatorInKeV
 from dodal.log import LOGGER
 
@@ -12,9 +12,8 @@ ENERGY_TIMEOUT_S: float = 30.0
 
 
 class UndulatorDCM(StandardReadable, Movable[float]):
-    """
-    Composite device to handle changing beamline energies, wraps the Undulator and the
-    DCM. The DCM has a motor which controls the beam energy, when it moves, the
+    """Composite device to handle changing beamline energies, wraps the Undulator and
+    the DCM. The DCM has a motor which controls the beam energy, when it moves, the
     Undulator gap may also have to change to enable emission at the new energy.
     The relationship between the two motor motor positions is provided via a lookup
     table.
@@ -24,7 +23,7 @@ class UndulatorDCM(StandardReadable, Movable[float]):
     a comprehensive way to set beam energy.
 
     This class will be removed in the future. Use the separate Undulator and DCM devices
-    instead. See https://github.com/DiamondLightSource/dodal/issues/1092
+    instead. See https://github.com/DiamondLightSource/dodal/issues/1092.
     """
 
     DCM_PERP_TOLERANCE = 0.01

dodal/devices/beamlines/i04/beam_centre.py

@@ -0,0 +1,151 @@
+import math
+
+import cv2
+import numpy as np
+from bluesky.protocols import Triggerable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+from ophyd_async.epics.core import (
+    epics_signal_r,
+)
+
+from dodal.devices.oav.utils import convert_to_gray_and_blur
+from dodal.log import LOGGER
+
+# Constant was chosen from trial and error with test images
+ADDITIONAL_BINARY_THRESH = 20
+
+
+def convert_image_to_binary(image: np.ndarray):
+    """Creates a binary image from OAV image array data.
+
+    Pixels of the input image are converted to one of two values (a high and a low value).
+    Otsu's method is used for automatic thresholding.
+    See https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html.
+    The threshold is increased by ADDITIONAL_BINARY_THRESH in order to get more of
+    the centre of the beam.
+    """
+    max_pixel_value = 255
+
+    blurred_image = convert_to_gray_and_blur(image)
+
+    threshold_value, _ = cv2.threshold(
+        blurred_image, 0, max_pixel_value, cv2.THRESH_BINARY + cv2.THRESH_OTSU
+    )
+
+    # Adjusting because the inner beam is less noisy compared to the outer
+    threshold_value += ADDITIONAL_BINARY_THRESH
+
+    _, thresholded_image = cv2.threshold(
+        blurred_image, threshold_value, max_pixel_value, cv2.THRESH_BINARY
+    )
+
+    LOGGER.info(f"Image binarised with threshold of {threshold_value}")
+    return thresholded_image
+
+
+def round_half_up(x):
+    return int(math.floor(x + 0.5))
+
+
+def get_roi(
+    image_arr: np.ndarray,
+    centre_x: int,
+    centre_y: int,
+    box_width: int = 200,
+    box_height: int = 200,
+) -> tuple[np.ndarray, tuple[int, int], tuple[int, int]]:
+    """Creates an ROI image array from a full screen image array, given a centre for the
+    ROI image and a width and height of the ROI box. Note that if the centre of the ROI
+    box is close to the edge of the full screen image, the box may be smaller than the
+    width and height provided, as the ROI will be trimmed to fit inside the full screen
+    image.
+
+    Args:
+        image_arr (np.ndarray): The full screen image array.
+        centre_x (int): The x coordinate of the centre of the ROI box.
+        centre_y (int): The y coordinate of the centre of the ROI box.
+        box_width (int, optional): The width of the ROI box. Defaults to 200.
+        box_height (int, optional): The height of the ROI box. Defaults to 200.
+
+    Returns:
+        tuple[np.ndarray, tuple[int, int], tuple[int, int]]: The ROI array, and (x, y)
+            coordinates of the top left and bottom right corners of the ROI box.
+    """
+    height, width = image_arr.shape[:2]
+    x_dist = (box_width) / 2
+    y_dist = (box_height) / 2
+
+    # Clip coordinates to stay within bounds
+    x_min = max(round_half_up(centre_x - x_dist), 0)
+    x_max = min(round_half_up(centre_x + x_dist), width) - 1
+    y_min = max(round_half_up(centre_y - y_dist), 0)
+    y_max = min(round_half_up(centre_y + y_dist), height) - 1
+
+    roi_arr = image_arr[y_min : y_max + 1, x_min : x_max + 1]
+
+    return roi_arr, (x_min, y_min), (x_max, y_max)
+
+
+class CentreEllipseMethod(StandardReadable, Triggerable):
+    """Upon triggering, fits an ellipse to a binary image from the area detector defined
+    by the prefix.
+
+    This is used, in conjunction with a scintillator, to determine the centre of the
+    beam on the image.
+    """
+
+    def __init__(self, prefix: str, overlay_channel: int = 1, name: str = ""):
+        self.oav_array_signal = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
+
+        self.center_x_val, self._center_x_val_setter = soft_signal_r_and_setter(float)
+        self.center_y_val, self._center_y_val_setter = soft_signal_r_and_setter(float)
+
+        self.current_centre_x = epics_signal_r(
+            int, f"{prefix}OVER:{overlay_channel}:CenterX"
+        )
+        self.current_centre_y = epics_signal_r(
+            int, f"{prefix}OVER:{overlay_channel}:CenterY"
+        )
+
+        self.roi_box_size = soft_signal_rw(int, 300)
+
+        super().__init__(name)
+
+    def _fit_ellipse(self, binary_img: cv2.typing.MatLike) -> cv2.typing.RotatedRect:
+        contours, _ = cv2.findContours(
+            binary_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
+        )
+        if not contours:
+            raise ValueError("No contours found in image.")
+
+        largest_contour = max(contours, key=cv2.contourArea)
+        if len(largest_contour) < 5:
+            raise ValueError(
+                f"Not enough points to fit an ellipse. Found {largest_contour} points and need at least 5."
+            )
+
+        return cv2.fitEllipse(largest_contour)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        array_data = await self.oav_array_signal.get_value()
+        current_x = await self.current_centre_x.get_value()
+        current_y = await self.current_centre_y.get_value()
+        roi_box_size = await self.roi_box_size.get_value()
+
+        roi_data, top_left_corner, _ = get_roi(
+            array_data, current_x, current_y, roi_box_size, roi_box_size
+        )
+
+        roi_binary = convert_image_to_binary(roi_data)
+        ellipse_fit = self._fit_ellipse(roi_binary)
+        roi_centre_x = ellipse_fit[0][0]
+        roi_centre_y = ellipse_fit[0][1]
+        # convert back to full screen image coords and set beam centre
+        self._center_x_val_setter(roi_centre_x + top_left_corner[0])
+        self._center_y_val_setter(roi_centre_y + top_left_corner[1])

dodal/devices/{i04 → beamlines/i04}/beamsize.py

@@ -1,11 +1,15 @@
 from ophyd_async.core import Reference, derived_signal_r
 
 from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.beamlines.i04.transfocator import Transfocator
 from dodal.devices.beamsize.beamsize import BeamsizeBase
-from dodal.devices.i04.transfocator import Transfocator
 
 
 class Beamsize(BeamsizeBase):
+    """Device that calculates the size of the beam by taking the minimum of the
+    transfocator size and the aperture scatterguard diameter.
+    """
+
     def __init__(
         self,
         transfocator: Transfocator,
@@ -20,26 +24,26 @@ class Beamsize(BeamsizeBase):
             self.x_um = derived_signal_r(
                 self._get_beamsize_x,
                 transfocator_size_x=self._transfocator_ref().current_horizontal_size_rbv,
-                aperture_radius=self._aperture_scatterguard_ref().radius,
+                aperture_diameter=self._aperture_scatterguard_ref().diameter,
                 derived_units="µm",
             )
             self.y_um = derived_signal_r(
                 self._get_beamsize_y,
                 transfocator_size_y=self._transfocator_ref().current_vertical_size_rbv,
-                aperture_radius=self._aperture_scatterguard_ref().radius,
+                aperture_diameter=self._aperture_scatterguard_ref().diameter,
                 derived_units="µm",
             )
 
     def _get_beamsize_x(
         self,
         transfocator_size_x: float,
-        aperture_radius: float,
+        aperture_diameter: float,
     ) -> float:
-        return min(transfocator_size_x, aperture_radius)
+        return min(transfocator_size_x, aperture_diameter)
 
     def _get_beamsize_y(
         self,
         transfocator_size_y: float,
-        aperture_radius: float,
+        aperture_diameter: float,
     ) -> float:
-        return min(transfocator_size_y, aperture_radius)
+        return min(transfocator_size_y, aperture_diameter)

dodal/devices/{i04 → beamlines/i04}/murko_results.py

@@ -15,7 +15,7 @@ from ophyd_async.core import (
 )
 from redis.asyncio import ConnectionError, StrictRedis
 
-from dodal.devices.i04.constants import RedisConstants
+from dodal.devices.beamlines.i04.constants import RedisConstants
 from dodal.devices.oav.oav_calculations import (
     calculate_beam_distance,
 )
@@ -238,7 +238,6 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         remove many of the outliers. Murko also occasionally picks a point in the bottom
         left corner, which can be removed by filtering results with a small x pixel.
         """
-
         LOGGER.info(f"Number of results before filtering: {len(self._results)}")
         sorted_results = sorted(self._results, key=lambda item: item.chosen_point_px[0])
 
@@ -278,15 +277,16 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
 
 
 def get_yz_least_squares(vertical_dists: list, omegas: list) -> tuple[float, float]:
-    """Get the least squares solution for y and z from the vertical distances and omega angles.
+    """Get the least squares solution for y and z from the vertical distances and omega
+    angles.
 
     Args:
-        v_dists (list): List of vertical distances from beam centre. Any units
+        vertical_dists (list): List of vertical distances from beam centre. Any units.
         omegas (list): List of omega angles in degrees.
 
     Returns:
         tuple[float, float]: y, z distances from centre, in whichever units
-        v_dists came as.
+            v_dists came as.
     """
     thetas = np.radians(omegas)
     matrix = np.column_stack([np.cos(thetas), -np.sin(thetas)])

dodal/devices/{i04 → beamlines/i04}/transfocator.py

@@ -3,7 +3,6 @@ import asyncio
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
-    observe_value,
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
@@ -49,24 +48,20 @@ class Transfocator(StandardReadable):
     @AsyncStatus.wrap
     async def set(self, value: float):
         """To set the beamsize on the transfocator we must:
-        1. Set the beamsize in the calculator part of the transfocator
-        2. Get the predicted number of lenses needed from this calculator
-        3. Enter this back into the device
-        4. Start the device moving
-        5. Wait for the start_rbv goes high and low again
+        1. Set the beamsize in the calculator part of the transfocator.
+        2. Get the predicted number of lenses needed from this calculator.
+        3. Enter this back into the device.
+        4. Start the device moving.
+        5. Wait for the start_rbv goes high and low again.
         """
         LOGGER.info(f"Transfocator setting {value} beamsize")
 
-        # Logic in the IOC calculates _num_lenses_calc_rbv when _vert_size_calc_sp changes
-
-        # Register an observer before setting _vert_size_calc_sp to ensure we don't miss changes
-        num_lenses_calc_iterator = observe_value(
-            self._num_lenses_calc_rbv, timeout=self.TIMEOUT
-        )
-
-        await anext(num_lenses_calc_iterator)
         await self._vert_size_calc_sp.set(value)
-        calc_lenses = await anext(num_lenses_calc_iterator)
+        # Logic in the IOC calculates _num_lenses_calc_rbv when _vert_size_calc_sp changes,
+        # but this isn't instant so we need a short sleep until
+        # https://jira.diamond.ac.uk/browse/I04-1100
+        await asyncio.sleep(0.1)
+        calc_lenses = await self._num_lenses_calc_rbv.get_value()
 
         async with periodic_reminder(
             f"Waiting for transfocator to insert {calc_lenses} into beam"

dodal/devices/beamlines/i05/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.beamlines.i05.enums import Grating
+
+__all__ = ["Grating"]

dodal/devices/beamlines/i06_shared/__init__.py

@@ -0,0 +1,3 @@
+from .i06_enum import I06Grating
+
+__all__ = ["I06Grating"]

dodal/devices/beamlines/i06_shared/i06_enum.py

@@ -0,0 +1,7 @@
+from ophyd_async.core import StrictEnum
+
+
+class I06Grating(StrictEnum):
+    GRATING_150 = "150 lines/mm"
+    GRATING_400 = "400 lines/mm"
+    GRATING_1200 = "1200 lines/mm"

dodal/devices/{i07 → beamlines/i07}/dcm.py

@@ -9,9 +9,8 @@ from dodal.devices.common_dcm import (
 
 
 class DCM(DoubleCrystalMonochromator[PitchAndRollCrystal, StationaryCrystal]):
-    """
-    Device for i07's DCM, including temperature monitors and vertical motor which were
-    included in GDA.
+    """Device for i07's DCM, including temperature monitors and vertical motor which
+    were included in GDA.
     """
 
     def __init__(

dodal/devices/{i07 → beamlines/i07}/id.py

@@ -5,34 +5,33 @@ from dodal.devices.util.lookup_tables import energy_distance_table
 
 
 class InsertionDevice(UndulatorInKeV):
-    """
-    Insertion device for i07 including beamline-specific energy-gap lookup behaviour
+    """Insertion device for i07 including beamline-specific energy-gap lookup
+    behaviour.
     """
 
     def __init__(
         self,
-        name: str,
         prefix: str,
         harmonic: UndulatorOrder,
         id_gap_lookup_table_path: str = "/dls_sw/i07/software/gda/config/lookupTables/"
         + "IIDCalibrationTable.txt",
-    ) -> None:
+        name: str = "",
+    ):
         super().__init__(prefix, id_gap_lookup_table_path, name=name)
         self.harmonic = harmonic
 
     async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
-        """
-        i07's energy scans remain on a particular harmonic while changing energy.  The
+        """i07's energy scans remain on a particular harmonic while changing energy. The
         calibration table has one row for each harmonic, row contains max and min
         energies and their corresponding ID gaps.  The requested energy is used to
         interpolate between these values, assuming a linear relationship on the relevant
         scale.
         """
-        energy_to_distance_table: np.ndarray = await energy_distance_table(
+        energy_to_distance_table = await energy_distance_table(
             self.id_gap_lookup_table_path, comments="#", skiprows=2
         )
-        harmonic_value: int = await self.harmonic.value.get_value()
+        harmonic_value = await self.harmonic.value.get_value()
 
-        row: np.ndarray = energy_to_distance_table[harmonic_value - 1, :]
+        row = energy_to_distance_table[harmonic_value - 1, :]
         gap = np.interp(energy_kev, [row[1], row[2]], [row[3], row[4]])
         return gap

dodal/devices/beamlines/i09/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.beamlines.i09.enums import Grating, LensMode, PassEnergy, PsuMode
+
+__all__ = ["Grating", "LensMode", "PsuMode", "PassEnergy"]