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

dodal/devices/i19/mapt_configuration.py

@@ -0,0 +1,38 @@
+from ophyd_async.core import DeviceVector, SignalR, StandardReadable, SubsetEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
+
+
+class MAPTConfigurationTable(StandardReadable):
+    """Readable device that can be used to build the read-only MAPT (Mini Apertures)
+    configuration table in controls for aperture motors in the available positions.
+    For each aperture it sets up a readable signal with the position of all the motors
+    in the MAPT configuration.
+    This device can be used to build the table for both eh1 and eh2 on I19, in
+    combination with the MAPTConfigurationControl device.
+    """
+
+    def __init__(
+        self, prefix: str, motor_name: str, aperture_list: list[int], name: str = ""
+    ) -> None:
+        with self.add_children_as_readables():
+            self.in_positions: DeviceVector[SignalR[float]] = DeviceVector(
+                {
+                    pos: epics_signal_r(float, f"{prefix}:{pos}UM:{motor_name}")
+                    for pos in aperture_list
+                }
+            )
+        super().__init__(name)
+
+
+class MAPTConfigurationControl(StandardReadable):
+    """A device to control the MAPT (Mini Aperture) configuration. It provides a signal
+    to set the configuration PV to the requested value and a triggerable signal that
+    will move all the motors to the correct position."""
+
+    def __init__(
+        self, prefix: str, aperture_request: type[SubsetEnum], name: str = ""
+    ) -> None:
+        with self.add_children_as_readables():
+            self.select_config = epics_signal_rw(aperture_request, f"{prefix}")
+        self.apply_selection = epics_signal_x(f"{prefix}:APPLY.PROC")
+        super().__init__(name)

dodal/devices/i19/pin_col_stages.py

@@ -0,0 +1,170 @@
+import asyncio
+from enum import StrEnum
+
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable, SubsetEnum
+from ophyd_async.epics.core import epics_signal_r
+from pydantic import BaseModel
+
+from dodal.devices.i19.mapt_configuration import (
+    MAPTConfigurationControl,
+    MAPTConfigurationTable,
+)
+from dodal.devices.motors import XYStage
+from dodal.log import LOGGER
+
+_PIN = "-MO-PIN-01:"
+_COL = "-MO-COL-01:"
+_CONFIG = "-OP-PCOL-01:"
+
+
+class PinColRequest(StrEnum):
+    """Aperture request positions."""
+
+    PCOL20 = "20um"
+    PCOL40 = "40um"
+    PCOL100 = "100um"
+    PCOL3000 = "3000um"
+    OUT = "OUT"
+
+
+# NOTE. Using subset enum because from the OUT positions should only be used by
+# the beamline scientists from the synoptic. Another option will be needed in the
+# device for OUT position.
+class _PinColPosition(SubsetEnum):
+    """Aperture request IN positions."""
+
+    PCOL20 = "20um"
+    PCOL40 = "40um"
+    PCOL100 = "100um"
+    PCOL3000 = "3000um"
+
+
+class AperturePosition(BaseModel):
+    """Describe the positions of the pinhole and collimator stage motors for
+    one of the available apertures.
+
+    Attributes:
+        pinhole_x: The position of the x motor on the pinhole stage
+        pinhole_y: The position of the y motor on the pinhole stage
+        collimator_x: The position of the x motor on the collimator stage
+        collimator_y: The position of the y motor on the collimator stage
+    """
+
+    pinhole_x: float
+    pinhole_y: float
+    collimator_x: float
+    collimator_y: float
+
+
+class PinColConfiguration(StandardReadable):
+    """Full MAPT configuration table, including out positions and selection for the
+    Pinhole and Collimator control."""
+
+    def __init__(self, prefix: str, apertures: list[int], name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.configuration = MAPTConfigurationControl(prefix, _PinColPosition)
+            self.pin_x = MAPTConfigurationTable(prefix, "PINX", apertures)
+            self.pin_y = MAPTConfigurationTable(prefix, "PINY", apertures)
+            self.col_x = MAPTConfigurationTable(prefix, "COLX", apertures)
+            self.col_y = MAPTConfigurationTable(prefix, "COLY", apertures)
+            self.pin_x_out = epics_signal_r(float, f"{prefix}:OUT:PINX")
+            self.col_x_out = epics_signal_r(float, f"{prefix}:OUT:COLX")
+        super().__init__(name)
+
+
+class PinholeCollimatorControl(StandardReadable, Movable[str]):
+    """Device to control the Pinhole and Collimator stages moves on I19-2, using the
+    MAPT configuration table to look up the positions."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        pin_infix: str = _PIN,
+        col_infix: str = _COL,
+        config_infix: str = _CONFIG,
+    ):
+        self._aperture_sizes = [self._get_aperture_size(i) for i in _PinColPosition]
+        with self.add_children_as_readables():
+            self._pinhole = XYStage(f"{prefix}{pin_infix}")
+            self._collimator = XYStage(f"{prefix}{col_infix}")
+            self.mapt = PinColConfiguration(
+                f"{prefix}{config_infix}CONFIG", apertures=self._aperture_sizes
+            )
+        super().__init__(name=name)
+
+    def _get_aperture_size(self, ap_request: str) -> int:
+        return int(ap_request.strip("um"))
+
+    async def _get_motor_positions_for_requested_aperture(
+        self, ap_request: _PinColPosition
+    ) -> AperturePosition:
+        val = self._get_aperture_size(ap_request.value)
+
+        pinx = await self.mapt.pin_x.in_positions[val].get_value()
+        piny = await self.mapt.pin_y.in_positions[val].get_value()
+        colx = await self.mapt.col_x.in_positions[val].get_value()
+        coly = await self.mapt.col_y.in_positions[val].get_value()
+
+        return AperturePosition(
+            pinhole_x=pinx, pinhole_y=piny, collimator_x=colx, collimator_y=coly
+        )
+
+    async def _safe_move_out(self):
+        """Move the pinhole and collimator stages safely to the out position, which
+        involves only the x motors of the stages.
+        In order to avoid a collision, we have to make sure that the collimator stage is
+        always moved out first and the pinhole stage second.
+        """
+        LOGGER.info("Moving pinhole and collimator stages to out position")
+        colx_out = await self.mapt.col_x_out.get_value()
+        pin_x_out = await self.mapt.pin_x_out.get_value()
+        # First move Collimator x motor
+        LOGGER.debug(f"Move collimator stage x motor to {colx_out}")
+        await self._collimator.x.set(colx_out)
+        # Then move Pinhole x motor
+        LOGGER.debug(f"Move pinhole stage x motor to {pin_x_out}")
+        await self._pinhole.x.set(pin_x_out)
+
+    async def _safe_move_in(self, value: _PinColPosition):
+        """Move the pinhole and collimator stages safely to the in position.
+        In order to avoid a collision, we have to make sure that the pinhole stage is
+        always moved in before the collimator stage."""
+        LOGGER.info(
+            f"Moving pinhole and collimator stages to in position: {value.value}"
+        )
+        await self.mapt.configuration.select_config.set(value, wait=True)
+        # NOTE. The apply PV will not be used here unless fixed in controls first.
+        # This is to avoid collisions. A safe move in will move first the pinhole stage
+        # and then the collimator stage, but apply will try to move all the motors
+        # at the same time.
+        aperture_positions = await self._get_motor_positions_for_requested_aperture(
+            value
+        )
+        LOGGER.debug(f"Moving motors to {aperture_positions}")
+
+        # First move Pinhole motors,
+        LOGGER.debug("Moving pinhole stage in")
+        await asyncio.gather(
+            self._pinhole.x.set(aperture_positions.pinhole_x),
+            self._pinhole.y.set(aperture_positions.pinhole_y),
+        )
+        # Then move Collimator motors
+        LOGGER.debug("Moving collimator stage in")
+        await asyncio.gather(
+            self._collimator.x.set(aperture_positions.collimator_x),
+            self._collimator.y.set(aperture_positions.collimator_y),
+        )
+
+    @AsyncStatus.wrap
+    async def set(self, value: PinColRequest):
+        """Moves the motor stages to the position for the requested aperture while
+        avoiding possible collisions.
+        The request coming from a plan should always be one of accepted request values:
+        ('20um', '40um', '100um', '3000um', 'OUT').
+        """
+        if value is PinColRequest.OUT:
+            await self._safe_move_out()
+        else:
+            await self._safe_move_in(_PinColPosition(value))

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.
 

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/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: