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

dodal/devices/ipin.py

@@ -20,7 +20,7 @@ class IPinGain(SubsetEnum):
 
 
 class IPin(StandardReadable):
-    """Simple device to get the ipin reading"""
+    """Simple device to get the ipin reading."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables(

dodal/devices/linkam3.py

@@ -14,15 +14,17 @@ class PumpControl(StrictEnum):
 # TODO: Make use of Status PV:
 # https://github.com/DiamondLightSource/dodal/issues/338
 class Linkam3(StandardReadable):
-    """Device to represent a Linkam3 temperature controller
+    """Device to represent a Linkam3 temperature controller.
 
     Attributes:
-        tolerance (float): Deadband around the setpoint within which the position is assumed to have been reached
-        settle_time (int): The delay between reaching the setpoint and the move being considered complete
+        tolerance (float): Deadband around the setpoint within which the position is
+            assumed to have been reached.
+        settle_time (int): The delay between reaching the setpoint and the move being
+            considered complete.
 
     Args:
-        prefix (str): PV prefix for this device
-        name (str): unique name for this device
+        prefix (str): PV prefix for this device.
+        name (str): Unique name for this device.
     """
 
     tolerance: float = 0.5

dodal/devices/motors.py

@@ -8,29 +8,31 @@ from ophyd_async.epics.motor import Motor
 _X, _Y, _Z = "X", "Y", "Z"
 
 _OMEGA = "OMEGA"
+_POLAR = "POLAR"
+_AZIMUTH = "AZIMUTH"
+_TILT = "TILT"
 
 
 class Stage(StandardReadable, ABC):
-    """
-    For these devices, the following co-ordinates are typical but not enforced:
+    """For these devices, the following co-ordinates are typical but not enforced:
     - z is horizontal & parallel to the direction of beam travel
     - y is vertical and antiparallel to the force of gravity
     - x is the cross product of y🞬z
 
-    Parameters
-    ----------
-    prefix:
-        Common part of the EPICS PV for all motors, including ":".
-    name:
-        Name of the stage, each child motor will be named "{name}-{field_name}"
-    *_infix:
-        Infix between the common prefix and the EPICS motor record fields for the field.
-    """
+    Attributes:
+        prefix (str): Common part of the EPICS PV for all motors, including ":".
+        name (str, optional): Name of the stage, each child motor will be named
+            "{name}-{field_name}".
+        *_infix: Infix between the common prefix and the EPICS motor record fields for
+            the field.
+    """  # noqa D415
 
     ...
 
 
 class XThetaStage(Stage):
+    """Two-axis stage with an x and a theta motor."""
+
     def __init__(
         self, prefix: str, name: str = "", x_infix: str = _X, theta_infix: str = "A"
     ):
@@ -41,6 +43,8 @@ class XThetaStage(Stage):
 
 
 class XYStage(Stage):
+    """A standard two-axis stage with an x and a y motor."""
+
     def __init__(
         self, prefix: str, name: str = "", x_infix: str = _X, y_infix: str = _Y
     ):
@@ -51,6 +55,8 @@ class XYStage(Stage):
 
 
 class XYZStage(XYStage):
+    """A standard three-axis stage with an x, a y, and a z motor."""
+
     def __init__(
         self,
         prefix: str,
@@ -65,6 +71,8 @@ class XYZStage(XYStage):
 
 
 class XYZThetaStage(XYZStage):
+    """Four-axis stage with a standard xyz stage and one axis of rotation: theta."""
+
     def __init__(
         self,
         prefix: str,
@@ -80,6 +88,8 @@ class XYZThetaStage(XYZStage):
 
 
 class XYZOmegaStage(XYZStage):
+    """Four-axis stage with a standard xyz stage and one axis of rotation: omega."""
+
     def __init__(
         self,
         prefix: str,
@@ -94,7 +104,69 @@ class XYZOmegaStage(XYZStage):
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
 
+class XYZPolarStage(XYZStage):
+    """Four-axis stage with a standard xyz stage and one axis of rotation: polar."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        polar_infix: str = _POLAR,
+    ) -> None:
+        with self.add_children_as_readables():
+            self.polar = Motor(prefix + polar_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
+class XYZPolarAzimuthStage(XYZPolarStage):
+    """Five-axis stage with a standard xyz stage and two axis of rotation: polar and
+    azimuth.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        polar_infix: str = _POLAR,
+        azimuth_infix: str = _AZIMUTH,
+    ):
+        with self.add_children_as_readables():
+            self.azimuth = Motor(prefix + azimuth_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix, polar_infix)
+
+
+class XYZPolarAzimuthTiltStage(XYZPolarAzimuthStage):
+    """Six-axis stage with a standard xyz stage and three axis of rotation: polar,
+    azimuth and tilt.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        polar_infix: str = _POLAR,
+        azimuth_infix: str = _AZIMUTH,
+        tilt_infix: str = _TILT,
+    ):
+        with self.add_children_as_readables():
+            self.tilt = Motor(prefix + tilt_infix)
+        super().__init__(
+            prefix, name, x_infix, y_infix, z_infix, polar_infix, azimuth_infix
+        )
+
+
 class XYPhiStage(XYStage):
+    """Three-axis stage with a standard xy stage and one axis of rotation: phi."""
+
     def __init__(
         self,
         prefix: str,
@@ -109,6 +181,8 @@ class XYPhiStage(XYStage):
 
 
 class XYPitchStage(XYStage):
+    """Three-axis stage with a standard xy stage and one axis of rotation: pitch."""
+
     def __init__(
         self,
         prefix: str,
@@ -123,6 +197,8 @@ class XYPitchStage(XYStage):
 
 
 class XYRollStage(XYStage):
+    """Three-axis stage with a standard xy stage and one axis of rotation: roll."""
+
     def __init__(
         self,
         prefix: str,
@@ -137,6 +213,10 @@ class XYRollStage(XYStage):
 
 
 class XYZPitchYawStage(XYZStage):
+    """Five-axis stage with a standard xyz stage and two axes of rotation: pitch and
+    yaw.
+    """
+
     def __init__(
         self,
         prefix: str,
@@ -154,6 +234,10 @@ class XYZPitchYawStage(XYZStage):
 
 
 class XYZPitchYawRollStage(XYZStage):
+    """Five-axis stage with a standard xyz stage and three axes of rotation: pitch, yaw,
+    and roll.
+    """
+
     def __init__(
         self,
         prefix: str,
@@ -173,6 +257,10 @@ class XYZPitchYawRollStage(XYZStage):
 
 
 class SixAxisGonio(XYZOmegaStage):
+    """Six-axis goniometer with a standard xyz stage and three axes of rotation:
+    kappa, phi and omega.
+    """
+
     def __init__(
         self,
         prefix: str,
@@ -184,9 +272,6 @@ class SixAxisGonio(XYZOmegaStage):
         phi_infix: str = "PHI",
         omega_infix: str = _OMEGA,
     ):
-        """Six-axis goniometer with a standard xyz stage and three axes of rotation:
-        kappa, phi and omega.
-        """
         with self.add_children_as_readables():
             self.kappa = Motor(prefix + kappa_infix)
             self.phi = Motor(prefix + phi_infix)
@@ -198,6 +283,10 @@ class SixAxisGonio(XYZOmegaStage):
 
 
 class SixAxisGonioKappaPhi(XYZStage):
+    """Six-axis goniometer with a standard xyz stage and two axes of rotation:
+    kappa and phi.
+    """
+
     def __init__(
         self,
         prefix: str,
@@ -208,9 +297,6 @@ class SixAxisGonioKappaPhi(XYZStage):
         kappa_infix: str = "KAPPA",
         phi_infix: str = "PHI",
     ):
-        """Six-axis goniometer with a standard xyz stage and two axes of rotation:
-        kappa and phi.
-        """
         with self.add_children_as_readables():
             self.kappa = Motor(prefix + kappa_infix)
             self.phi = Motor(prefix + phi_infix)
@@ -218,6 +304,8 @@ class SixAxisGonioKappaPhi(XYZStage):
 
 
 class YZStage(Stage):
+    """Two-axis stage with an x and a z motor."""
+
     def __init__(
         self, prefix: str, name: str = "", y_infix: str = _Y, z_infix: str = _Z
     ) -> None:
@@ -244,9 +332,9 @@ def create_axis_perp_to_rotation(motor_theta: Motor, motor_i: Motor, motor_j: Mo
     Args:
         motor_theta (Motor): this is the rotation axis of the sample.
         motor_i (Motor): this is the axis that, when the sample is at 0 deg rotation,
-                         a move here is entirely parallel with the derived axis.
+            a move here is entirely parallel with the derived axis.
         motor_j (Motor): this is the axis that, when the sample is at 90 deg rotation,
-                         a move here is entirely parallel with the derived axis.
+            a move here is entirely parallel with the derived axis.
     """
 
     def _get(j_val: float, i_val: float, rot_value: float) -> float:

dodal/devices/mx_phase1/beamstop.py

@@ -14,8 +14,7 @@ _BEAMSTOP_OUT_DELTA_Y_MM = -2
 
 
 class BeamstopPositions(StrictEnum):
-    """
-    Beamstop positions.
+    """Beamstop positions.
     GDA supports Standard/High/Low resolution positions, as well as parked and
     robot load however all 3 resolution positions are the same. We also
     do not use the robot load position in Hyperion.
@@ -35,8 +34,7 @@ class BeamstopPositions(StrictEnum):
 
 
 class Beamstop(StandardReadable):
-    """
-    Beamstop for I03 and I04.
+    """Beamstop for I03 and I04.
 
     Attributes:
         x: beamstop x position in mm

dodal/devices/oav/oav_calculations.py

@@ -11,19 +11,24 @@ def camera_coordinates_to_xyz_mm(
     y_vertical_sign: int,
     z_vertical_sign: int,
 ) -> np.ndarray:
-    """
-    Converts from (horizontal,vertical) pixel measurements from the OAV camera into to (x, y, z) motor coordinates in millimetres.
-    For an overview of the coordinate system for I03 see https://github.com/DiamondLightSource/hyperion/wiki/Gridscan-Coordinate-System.
+    """Converts from (horizontal,vertical) pixel measurements from the OAV camera into
+    to (x, y, z) motor coordinates in millimetres.
+    For an overview of the coordinate system for I03 see
+    https://github.com/DiamondLightSource/hyperion/wiki/Gridscan-Coordinate-System.
 
     Args:
         horizontal (float): A i value from the camera in pixels.
         vertical (float): A j value from the camera in pixels.
-        omega (float): The omega angle of the smargon that the horizontal, vertical measurements were obtained at.
-        microns_per_i_pixel (float): The number of microns per i pixel, adjusted for the zoom level horizontal was measured at.
-        microns_per_j_pixel (float): The number of microns per j pixel, adjusted for the zoom level vertical was measured at.
-        x_horizontal_sign (int): Direction mapping for x, positive means the oav and motor are on same direction, default from hyperion
-        y_vertical_sign (int): Direction mapping for y
-        z_vertical_sign (int): Direction mapping for z
+        omega (float): The omega angle of the smargon that the horizontal, vertical
+            measurements were obtained at.
+        microns_per_i_pixel (float): The number of microns per i pixel, adjusted for
+            the zoom level horizontal was measured at.
+        microns_per_j_pixel (float): The number of microns per j pixel, adjusted for
+            the zoom level vertical was measured at.
+        x_horizontal_sign (int): Direction mapping for x, positive means the oav and
+            motor are on same direction, default from hyperion.
+        y_vertical_sign (int): Direction mapping for y.
+        z_vertical_sign (int): Direction mapping for z.
     """
     # Convert the vertical and horizontal into mm.
     horizontal *= microns_per_i_pixel * 1e-3
@@ -49,15 +54,17 @@ def calculate_beam_distance(
     horizontal_pixels: int,
     vertical_pixels: int,
 ) -> tuple[int, int]:
-    """
-    Calculates the distance between the beam centre and the given (horizontal, vertical).
+    """Calculates the distance between the beam centre and the given (horizontal,
+    vertical).
 
     Args:
+        beam_centre (tuple[int, int]): The position of the beam in pixels.
         horizontal_pixels (int): The x (camera coordinates) value in pixels.
         vertical_pixels (int): The y (camera coordinates) value in pixels.
+
     Returns:
-        The distance between the beam centre and the (horizontal, vertical) point in pixels as a tuple
-        (horizontal_distance, vertical_distance).
+        tuple: The distance between the beam centre and the (horizontal, vertical) point
+            in pixels as a tuple (horizontal_distance, vertical_distance).
     """
     beam_x, beam_y = beam_centre
     return (

dodal/devices/oav/oav_detector.py

@@ -1,13 +1,17 @@
+import asyncio
 from enum import IntEnum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DeviceMock,
+    DeviceVector,
     LazyMock,
     SignalR,
     SignalRW,
     StandardReadable,
+    default_mock_class,
     derived_signal_r,
     soft_signal_rw,
 )
@@ -22,6 +26,7 @@ from dodal.devices.oav.oav_parameters import (
 )
 from dodal.devices.oav.snapshots.snapshot import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
+from dodal.log import LOGGER
 
 
 class Coords(IntEnum):
@@ -56,37 +61,99 @@ class NullZoomController(BaseZoomController):
             await self.level.set(value, wait=True)
 
 
-class ZoomController(BaseZoomController):
+class BeamCentreForZoom(StandardReadable):
+    """These PVs hold the beam centre on the OAV at each zoom level.
+
+    When the zoom level is changed the IOC will update the OAV overlay PVs to be at
+    these positions.
     """
-    Device to control the zoom level. This should be set like
-        o = OAV(name="oav")
+
+    def __init__(
+        self, prefix: str, level_name_pv_suffix: str, centre_value_pv_suffix: str
+    ) -> None:
+        self.level_name = epics_signal_r(
+            str, f"{prefix}MP:SELECT.{level_name_pv_suffix}"
+        )
+        self.x_centre = epics_signal_rw(
+            float, f"{prefix}PBCX:VAL{centre_value_pv_suffix}"
+        )
+        self.y_centre = epics_signal_rw(
+            float, f"{prefix}PBCY:VAL{centre_value_pv_suffix}"
+        )
+        super().__init__()
+
+
+class InstantMovingZoom(DeviceMock["ZoomController"]):
+    """Mock behaviour that instantly moves the zoom."""
+
+    async def connect(self, device: "ZoomController") -> None:
+        """Mock signals to do an instant move on setpoint write."""
+        device.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S = 0.001  # type:ignore
+
+
+@default_mock_class(InstantMovingZoom)
+class ZoomController(BaseZoomController):
+    """Device to control the zoom level. This should be set like::
+
+        oav = OAV(name="oav")
         oav.zoom_controller.set("1.0x")
 
     Note that changing the zoom may change the AD wiring on the associated OAV, as such
-    you should wait on any zoom changs to finish before changing the OAV wiring.
-    """
+    you should wait on any zoom changes to finish before changing the OAV wiring.
+    """  # noqa 415
+
+    DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S = 2
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.percentage = epics_signal_rw(float, f"{prefix}ZOOMPOSCMD")
 
         # Level is the string description of the zoom level e.g. "1.0x" or "1.0"
         self.level = epics_signal_rw(str, f"{prefix}MP:SELECT")
+
         super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def set(self, value: str):
         await self.level.set(value, wait=True)
+        LOGGER.info(
+            f"Waiting {self.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S} seconds for zoom to be noticeable"
+        )
+        await asyncio.sleep(self.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S)
 
 
-class OAV(StandardReadable):
-    """
-    Class for oav device
+class ZoomControllerWithBeamCentres(ZoomController):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        level_to_centre_mapping = [
+            ("ZRST", "A"),
+            ("ONST", "B"),
+            ("TWST", "C"),
+            ("THST", "D"),
+            ("FRST", "E"),
+            ("FVST", "F"),
+            ("SXST", "G"),
+            ("SVST", "H"),
+        ]
+
+        self.beam_centres = DeviceVector(
+            {
+                i: BeamCentreForZoom(prefix, *level_to_centre_mapping[i])
+                for i in range(len(level_to_centre_mapping))
+            }
+        )
+
+        super().__init__(prefix, name)
+
 
-    x_direction(int): Should only be 1 or -1, with 1 indicating the oav x direction is the same with motor x
-    y_direction(int): Same with x_direction but for motor y
-    z_direction(int): Same with x_direction but for motor z
-    mjpg_x_size_pv(str): PV infix for x_size in mjpg
-    mjpg_y_size_pv(str): PV infix for y_size in mjpg
+class OAV(StandardReadable):
+    """Class for oav device.
+
+    Attributes:
+        x_direction(int, optional): Should only be 1 or -1, with 1 indicating the oav x
+            direction is the same with motor x.
+        y_direction(int, optional): Same with x_direction but for motor y.
+        z_direction(int, optional): Same with x_direction but for motor z.
+        mjpg_x_size_pv(str, optional): PV infix for x_size in mjpg.
+        mjpg_y_size_pv(str, optional): PV infix for y_size in mjpg.
     """
 
     beam_centre_i: SignalR[int]
@@ -118,6 +185,7 @@ class OAV(StandardReadable):
             self.zoom_controller = zoom_controller
 
         self.cam = Cam(f"{prefix}CAM:", name=name)
+
         with self.add_children_as_readables():
             self.grid_snapshot = SnapshotWithGrid(
                 f"{prefix}{mjpeg_prefix}:", name, mjpg_x_size_pv, mjpg_y_size_pv
@@ -170,16 +238,17 @@ class OAV(StandardReadable):
 
 
 class OAVBeamCentreFile(OAV):
-    """
-    OAV device that reads its beam centre values from a file. The config parameter
+    """OAV device that reads its beam centre values from a file. The config parameter
     must be a OAVConfigBeamCentre object, as this contains a filepath to where the beam
     centre values are stored.
 
-    x_direction(int): Should only be 1 or -1, with 1 indicating the oav x direction is the same with motor x
-    y_direction(int): Same with x_direction but for motor y
-    z_direction(int): Same with x_direction but for motor z
-    mjpg_x_size_pv(str): PV infix for x_size in mjpg
-    mjpg_y_size_pv(str): PV infix for y_size in mjpg
+    Attributes:
+        x_direction(int, optional): Should only be 1 or -1, with 1 indicating the oav x
+            direction is the same with motor x.
+        y_direction(int, optional): Same with x_direction but for motor y.
+        z_direction(int, optional): Same with x_direction but for motor z.
+        mjpg_x_size_pv(str, optional): PV infix for x_size in mjpg.
+        mjpg_y_size_pv(str, optional): PV infix for y_size in mjpg.
     """
 
     def __init__(
@@ -225,8 +294,9 @@ class OAVBeamCentreFile(OAV):
         self.set_name(self.name)
 
     def _get_beam_position(self, zoom_level: str, size: int, coord: int) -> int:
-        """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested \
-        zoom level. """
+        """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested
+        zoom level.
+        """
         _zoom = self._read_current_zoom(zoom_level)
         value = self.parameters[_zoom].crosshair[coord]
         return int(value * size / DEFAULT_OAV_WINDOW[coord])

dodal/devices/oav/oav_parameters.py

@@ -25,9 +25,7 @@ def _get_element_as_float(node: Element, element_name: str) -> float:
 
 
 class OAVParameters:
-    """
-    The parameters to set up the OAV depending on the context.
-    """
+    """The parameters to set up the OAV depending on the context."""
 
     def __init__(
         self,
@@ -45,8 +43,7 @@ class OAVParameters:
 
     @staticmethod
     def load_json(filename: str) -> tuple[dict[str, Any], dict[str, dict]]:
-        """
-        Loads the json from the specified file, and returns a dict with all the
+        """Loads the json from the specified file, and returns a dict with all the
         individual top-level k-v pairs, and one with all the subdicts.
         """
         with open(filename) as f:
@@ -101,9 +98,7 @@ class OAVParameters:
         self.max_tip_distance: float = update("max_tip_distance", float, default=300)
 
     def get_max_tip_distance_in_pixels(self, microns_per_pixel: float) -> float:
-        """
-        Get the maximum tip distance in pixels.
-        """
+        """Get the maximum tip distance in pixels."""
         return self.max_tip_distance / microns_per_pixel
 
 
@@ -154,7 +149,7 @@ class OAVConfig(OAVConfigBase[ZoomParams]):
 
 
 class OAVConfigBeamCentre(OAVConfigBase[ZoomParamsCrosshair]):
-    """ Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}\
+    """Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}
     with information about microns per pixels and crosshairs.
     """
 

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -45,12 +45,23 @@ class OAVSource(StandardReadable):
 
 
 class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
-    """Forwards OAV image data to redis. To use call:
+    """Forwards OAV image data to redis.
 
-    > bps.kickoff(oav_forwarder)
-    > bps.monitor(oav_forwarder.uuid)
-    > bps.complete(oav_forwarder)
+    To use call::
 
+        bps.kickoff(oav_forwarder)
+        bps.monitor(oav_forwarder.uuid)
+        bps.complete(oav_forwarder)
+
+    Reads image data from the MJPEG stream on an OAV and forwards it into a
+    redis database. This is currently only used for murko integration.
+
+    Args:
+        prefix (str): The PV prefix of the OAV.
+        redis_host (str): The host where the redis database is running.
+        redis_password (str): The password for the redis database.
+        redis_db (int): Which redis database to connect to, defaults to 0.
+        name (str): The name of this device.
     """
 
     DATA_EXPIRY_DAYS = 7
@@ -68,16 +79,6 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
         redis_db: int = 0,
         name: str = "",
     ) -> None:
-        """Reads image data from the MJPEG stream on an OAV and forwards it into a
-        redis database. This is currently only used for murko integration.
-
-        Arguments:
-            prefix: str             the PV prefix of the OAV
-            redis_host: str         the host where the redis database is running
-            redis_password: str     the password for the redis database
-            redis_db: int           which redis database to connect to, defaults to 0
-            name: str               the name of this device
-        """
         self.counter = epics_signal_r(int, f"{prefix}CAM:ArrayCounter_RBV")
         self.sources = DeviceVector(
             {
@@ -109,7 +110,9 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
     ):
         """Stores the raw bytes of the jpeg image in redis. Murko ultimately wants a
         pickled numpy array of pixel values but raw byes are more space efficient. There
-        may be better ways of doing this, see https://github.com/DiamondLightSource/mx-bluesky/issues/592"""
+        may be better ways of doing this, see
+        https://github.com/DiamondLightSource/mx-bluesky/issues/592.
+        """
         jpeg_bytes = await get_next_jpeg(response)
         sample_id = await self.sample_id.get_value()
         redis_key = f"murko:{sample_id}:raw"
@@ -131,12 +134,13 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
                 await function_to_do(response, source)
 
     async def _stream_to_redis(self, response: ClientResponse, source: OAVSource):
-        """Uses the update of the frame counter as a trigger to pull an image off the OAV
-        and into redis.
+        """Uses the update of the frame counter as a trigger to pull an image off the
+        OAV and into redis.
 
         The frame counter is continually increasing on the timescales we store data and
         so can be used as a uuid. If the OAV is updating too quickly we may drop frames
-        but in this case a best effort on getting as many frames as possible is sufficient.
+        but in this case a best effort on getting as many frames as possible is
+        sufficient.
         """
         done_status = AsyncStatus(
             asyncio.wait_for(self._stop_flag.wait(), timeout=self.TIMEOUT)