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

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

@@ -64,7 +64,9 @@ class NullZoomController(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."""
+    When the zoom level is changed the IOC will update the OAV overlay PVs to be at
+    these positions.
+    """
 
     def __init__(
         self, prefix: str, level_name_pv_suffix: str, centre_value_pv_suffix: str
@@ -91,14 +93,14 @@ class InstantMovingZoom(DeviceMock["ZoomController"]):
 
 @default_mock_class(InstantMovingZoom)
 class ZoomController(BaseZoomController):
-    """
-    Device to control the zoom level. This should be set like
-        o = OAV(name="oav")
+    """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 changes to finish before changing the OAV wiring.
-    """
+    """  # noqa 415
 
     DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S = 2
 
@@ -114,7 +116,7 @@ class ZoomController(BaseZoomController):
     async def set(self, value: str):
         await self.level.set(value, wait=True)
         LOGGER.info(
-            "Waiting {self.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S} seconds for zoom to be noticeable"
+            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)
 
@@ -143,14 +145,15 @@ class ZoomControllerWithBeamCentres(ZoomController):
 
 
 class OAV(StandardReadable):
-    """
-    Class for oav device
-
-    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 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]
@@ -235,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__(
@@ -290,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)

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -30,8 +30,7 @@ class InvalidPinError(Exception):
 
 
 class PinTipDetection(StandardReadable):
-    """
-    A device which will read from an on-axis view and calculate the location of the
+    """A device which will read from an on-axis view and calculate the location of the
     pin-tip (in pixels) of that frame.
 
     Used for pin tip centring workflow.
@@ -42,7 +41,8 @@ class PinTipDetection(StandardReadable):
     If no tip is found it will return {INVALID_POSITION}. However, it will also
     occasionally give incorrect data. Therefore, it is recommended that you trigger
     this device, which will attempt to find a pin within {validity_timeout} seconds if
-    no tip is found after this time it will not error but instead return {INVALID_POSITION}.
+    no tip is found after this time it will not error but instead return
+    {INVALID_POSITION}.
     """
 
     INVALID_POSITION = np.array([np.iinfo(np.int32).min, np.iinfo(np.int32).min])
@@ -98,9 +98,7 @@ class PinTipDetection(StandardReadable):
         self._bottom_edge_setter(results.edge_bottom)
 
     async def _get_tip_and_edge_data(self, array_data: np.ndarray) -> SampleLocation:
-        """
-        Gets the location of the pin tip and the top and bottom edges.
-        """
+        """Gets the location of the pin tip and the top and bottom edges."""
         preprocess_key = await self.preprocess_operation.get_value()
         preprocess_iter = await self.preprocess_iterations.get_value()
         preprocess_ksize = await self.preprocess_ksize.get_value()

dodal/devices/oav/pin_image_recognition/manual_test.py

@@ -1,5 +1,4 @@
-"""
-Note: this file exists exclusively to make it easier to manually run
+"""Note: this file exists exclusively to make it easier to manually run
 image recognition on a beamline without setting up all of the
 bluesky infrastructure.
 

dodal/devices/oav/pin_image_recognition/utils.py

@@ -100,9 +100,7 @@ NONE_VALUE: Final[int] = -1
 
 @dataclass
 class SampleLocation:
-    """
-    Holder type for results from sample detection.
-    """
+    """Holder type for results from sample detection."""
 
     tip_x: int | None
     tip_y: int | None
@@ -111,6 +109,28 @@ class SampleLocation:
 
 
 class MxSampleDetect:
+    """Configures sample detection parameters.
+
+    Args:
+        preprocess (Callable): A preprocessing function applied to the array after
+            conversion to grayscale. See implementations of common functions above
+            for predefined conversions. Defaults to a no-op (i.e. no preprocessing).
+
+        for open and close operations, please read:
+            https://docs.opencv.org/4.x/d9/d61/tutorial_py_morphological_ops.html
+
+        open_ksize (int, optional): Kernel size for "open" operation, if set to zero
+            then ignore "open" operation.
+        open_iterations (int, optional): Number of iterations for "open" operation.
+        canny_upper (int, optional): Upper threshold for canny edge detection.
+        canny_lower (int, optional): Lower threshold for canny edge detection.
+        close_ksize (int, optional): Kernel size for "close" operation.
+        close_iterations (int, optional): Number of iterations for "close" operation.
+        scan_direction (ScanDirections, optional): ScanDirections.FORWARD for
+            left-to-right, ScanDirections.REVERSE for right-to-left.
+        min_tip_height (int, optional): Minimum height of pin tip.
+    """
+
     def __init__(
         self,
         *,
@@ -124,27 +144,6 @@ class MxSampleDetect:
         scan_direction: ScanDirections = ScanDirections.FORWARD,
         min_tip_height: int = 5,
     ):
-        """
-        Configures sample detection parameters.
-
-        Args:
-            preprocess: A preprocessing function applied to the array after conversion to grayscale.
-                See implementations of common functions above for predefined conversions
-                Defaults to a no-op (i.e. no preprocessing)
-
-            for open and close operations, please read:
-                https://docs.opencv.org/4.x/d9/d61/tutorial_py_morphological_ops.html
-
-            open_ksize: kernel size for "open" operation, if set to zero then ignore "open" operation
-            open_iterations: number of iterations for "open" operation
-            canny_upper: upper threshold for canny edge detection
-            canny_lower: lower threshold for canny edge detection
-            close_ksize: kernel size for "close" operation
-            close_iterations: number of iterations for "close" operation
-            scan_direction: ScanDirections.FORWARD for left-to-right, ScanDirections.REVERSE for right-to-left
-            min_tip_height: minimum height of pin tip
-        """
-
         self.preprocess = preprocess
         self.open_ksize = open_ksize
         self.open_iterations = open_iterations
@@ -185,17 +184,16 @@ class MxSampleDetect:
     def _first_and_last_nonzero_by_columns(
         arr: np.ndarray,
     ) -> tuple[np.ndarray, np.ndarray]:
-        """
-        Finds the indexes of the first & last non-zero values by column in a 2d array.
+        """Finds the indexes of the first & last non-zero values by column in a 2d array.
 
         Outputs will contain NONE_VALUE if no non-zero values exist in a column.
 
-        i.e. for input:
-        [
-            [0, 0, 0, 1],
-            [1, 1, 0, 0],
-            [0, 1, 0, 1],
-        ]
+        i.e. for input::
+            [
+                [0, 0, 0, 1],
+                [1, 1, 0, 0],
+                [0, 1, 0, 1],
+            ]
 
         first_nonzero will be: [1, 1, NONE_VALUE, 0]
         last_nonzero will be [1, 2, NONE_VALUE, 2]