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

dodal/plans/bimorph.py

@@ -15,14 +15,14 @@ from dodal.devices.slits import Slits
 
 
 class SlitDimension(str, Enum):
-    """Enum representing the dimensions of a 2d slit
+    """Enum representing the dimensions of a 2d slit.
 
     Used to describe which dimension the pencil beam scan should move across.
     The other dimension will be held constant.
 
     Attributes:
-        X: Represents X dimension
-        Y: Represents Y dimension
+        X: Represents X dimension.
+        Y: Represents Y dimension.
     """
 
     X = "X"
@@ -33,10 +33,10 @@ def move_slits(slits: Slits, dimension: SlitDimension, gap: float, center: float
     """Moves ones dimension of Slits object to given position.
 
     Args:
-        slits: Slits to move
-        dimension: SlitDimension (X or Y)
-        gap: float size of gap
-        center: float position of center
+        slits (Slits): Slits to move.
+        dimension (SlitDimension): SlitDimension (X or Y).
+        gap (float): Size of gap.
+        center (float): Position of center.
     """
     if dimension == SlitDimension.X:
         yield from bps.mv(slits.x_gap, gap)
@@ -50,13 +50,14 @@ def check_valid_bimorph_state(
     voltage_list: list[float], abs_range: float, abs_diff: float
 ) -> bool:
     """Checks that a set of bimorph voltages is valid.
+
     Args:
-        voltage_list: float amount each actuator will be increased by per scan
-        abs_range: float absolute value of maximum possible voltage of each actuator
-        abs_diff: float absolute maximum difference between two consecutive actuators
+        voltage_list (list[float]): Amount each actuator will be increased by per scan.
+        abs_range (float): Absolute value of maximum possible voltage of each actuator.
+        abs_diff (float): Absolute maximum difference between two consecutive actuators.
 
     Returns:
-        Bool representing state validity
+        Bool: Representing state validity.
     """
     for voltage in voltage_list:
         if abs(voltage) > abs_range:
@@ -78,13 +79,17 @@ def validate_bimorph_plan(
     """Checks that every position the bimorph will move through will not error.
 
     Args:
-        initial_voltage_list: float list starting position
-        voltage_increment: float amount each actuator will be increased by per scan
-        abs_range: float absolute value of maximum possible voltage of each actuator
-        abs_diff: float absolute maximum difference between two consecutive actuators
+        initial_voltage_list (list[float]): Starting position.
+        voltage_increment (float): Amount each actuator will be increased by per scan.
+        abs_range (float): Absolute value of maximum possible voltage of each actuator.
+        abs_diff (float): Absolute maximum difference between two consecutive actuators.
+
+    Returns:
+        Bool: Representing state validity.
 
     Raises:
-        Exception if the plan will lead to an error state"""
+        Exception if the plan will lead to an error state.
+    """
     voltage_list = initial_voltage_list.copy()
 
     if not check_valid_bimorph_state(voltage_list, abs_range, abs_diff):
@@ -101,7 +106,7 @@ def validate_bimorph_plan(
 
 @dataclass
 class BimorphState:
-    """Data class containing positions of BimorphMirror and Slits"""
+    """Data class containing positions of BimorphMirror and Slits."""
 
     voltages: list[float]
     x_gap: float
@@ -114,11 +119,12 @@ def capture_bimorph_state(mirror: BimorphMirror, slits: Slits):
     """Plan stub that captures current position of BimorphMirror and Slits.
 
     Args:
-        mirror: BimorphMirror to read from
-        slits: Slits to read from
+        mirror (BimorphMirror): BimorphMirror to read from.
+        slits (Slits): Slits to read from.
 
     Returns:
-        A BimorphState containing BimorphMirror and Slits positions"""
+        A BimorphState containing BimorphMirror and Slits positions.
+    """
     original_voltage_list = []
 
     for channel in mirror.channels.values():
@@ -142,9 +148,9 @@ def restore_bimorph_state(mirror: BimorphMirror, slits: Slits, state: BimorphSta
     """Moves BimorphMirror and Slits to state given in BirmophState.
 
     Args:
-        mirror: BimorphMirror to move
-        slits: Slits to move
-        state: BimorphState to move to.
+        mirror (BimorphMirror): BimorphMirror to move.
+        slits (Slits): Slits to move.
+        state (BimorphState): BimorphState to move to.
     """
     yield from move_slits(slits, SlitDimension.X, state.x_gap, state.x_center)
     yield from move_slits(slits, SlitDimension.Y, state.y_gap, state.y_center)
@@ -158,11 +164,11 @@ def bimorph_position_generator(
     """Generator that produces bimorph positions, starting with the initial_voltage_list.
 
     Args:
-        initial_voltage_list: list starting position for bimorph
-        voltage_increment: float amount to increase each actuator by in turn
+        initial_voltage_list (list[float]): Starting position for bimorph.
+        voltage_increment (float): Amount to increase each actuator by in turn.
 
     Yields:
-        List bimorph positions, starting with initial_voltage_list
+        List bimorph positions, starting with initial_voltage_list.
     """
     voltage_list = initial_voltage_list.copy()
 
@@ -196,23 +202,25 @@ def bimorph_optimisation(
     bimorph mirror, of using a 2-dimensional slit.
 
     Args:
-        detectors: list[Readable] detectors
-        bimorph: BimorphMirror to move
-        slit: Slits
-        voltage_increment: float voltage increment applied to each bimorph electrode
-        active_dimension: SlitDimension that slit will move in (X or Y)
-        active_slit_center_start: float start position of center of slit in active dimension
-        active_slit_center_end: float final position of center of slit in active dimension
-        active_slit_size: float size of slit in active dimension
-        inactive_slit_center: float center of slit in inactive dimension
-        inactive_slit_size: float size of slit in inactive dimension
-        number_of_slit_positions: int number of slit positions per pencil beam scan
-        bimorph_settle_time: float time in seconds to wait after bimorph move
-        slit_settle_time: float time in seconds to wait after slit move
-        initial_voltage_list: optional list[float] starting voltages for bimorph (defaults to current voltages)
-        metadata: optional dict[str, Any] metadata to add to start document
+        detectors (list[Readable]): Detectors.
+        mirror (BimorphMirror): BimorphMirror to move.
+        slits (Slits): Slits.
+        voltage_increment (float): Voltage increment applied to each bimorph electrode.
+        active_dimension (SlitDimension): SlitDimension that slit will move in (X or Y).
+        active_slit_center_start (float): Start position of center of slit in active
+            dimension.
+        active_slit_center_end (float): Final position of center of slit in active
+            dimension.
+        active_slit_size (float): Size of slit in active dimension.
+        inactive_slit_center (float): Center of slit in inactive dimension.
+        inactive_slit_size (float): Size of slit in inactive dimension.
+        number_of_slit_positions (int): Number of slit positions per pencil beam scan.
+        bimorph_settle_time (float): Time in seconds to wait after bimorph move.
+        slit_settle_time (float): Time in seconds to wait after slit move.
+        initial_voltage_list (list[float], optional): Starting voltages for bimorph
+            (defaults to current voltages).
+        metadata (dict[string, Any], optional): Metadata to add to start document.
     """
-
     _metadata = {
         "plan_args": {
             "detectors": {det.name for det in detectors},
@@ -314,16 +322,19 @@ def inner_scan(
     """Inner plan stub, which moves Slits and performs a read.
 
     Args:
-        mirror: BimorphMirror to move
-        slit: Slits
-        oav: oav on-axis viewer
-        active_dimension: SlitDimension that slit will move in (X or Y)
-        active_slit_center_start: float start position of center of slit in active dimension
-        active_slit_center_end: float final position of center of slit in active dimension
-        active_slit_size: float size of slit in active dimension
-        number_of_slit_positions: int number of slit positions per pencil beam scan
-        slit_settle_time: float time in seconds to wait after slit move
-        stream_name: str name to pass to trigger_and_read
+        detectors (list[Readable]): Detectors to collect from.
+        mirror (BimorphMirror): BimorphMirror to move.
+        slits (Slits): Slits.
+        oav: oav on-axis viewer.
+        active_dimension (SlitDimension): SlitDimension that slit will move in (X or Y).
+        active_slit_center_start (float): Start position of center of slit in active
+            dimension.
+        active_slit_center_end (float): Final position of center of slit in active
+            dimension.
+        active_slit_size (float): Size of slit in active dimension.
+        number_of_slit_positions (int): Number of slit positions per pencil beam scan.
+        slit_settle_time (float): Time in seconds to wait after slit move.
+        stream_name (str): Name to pass to trigger_and_read.
     """
     for value in linspace(
         active_slit_center_start, active_slit_center_end, number_of_slit_positions

dodal/plans/device_setup_plans/__init__.py

@@ -0,0 +1,5 @@
+from dodal.plans.device_setup_plans.setup_pin_tip_params import (
+    setup_pin_tip_detection_params,
+)
+
+__all__ = ["setup_pin_tip_detection_params"]

dodal/plans/device_setup_plans/setup_pin_tip_params.py

@@ -0,0 +1,63 @@
+from functools import partial
+
+import bluesky.plan_stubs as bps
+
+from dodal.devices.oav.oav_parameters import OAVParameters
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+
+
+def setup_pin_tip_detection_params(
+    pin_tip_detect_device: PinTipDetection,
+    parameters: OAVParameters,
+    group: str = "pin_tip_parameters",
+    wait: bool = True,
+):
+    set_using_group = partial(bps.abs_set, group=group)
+    # select which blur to apply to image
+    yield from set_using_group(
+        pin_tip_detect_device.preprocess_operation, parameters.preprocess
+    )
+
+    # sets length scale for blurring
+    yield from set_using_group(
+        pin_tip_detect_device.preprocess_ksize, parameters.preprocess_K_size
+    )
+
+    # sets iteration for blur
+    yield from set_using_group(
+        pin_tip_detect_device.preprocess_iterations, parameters.preprocess_iter
+    )
+
+    # Canny edge detect - lower
+    yield from set_using_group(
+        pin_tip_detect_device.canny_lower_threshold,
+        parameters.canny_edge_lower_threshold,
+    )
+
+    # Canny edge detect - upper
+    yield from set_using_group(
+        pin_tip_detect_device.canny_upper_threshold,
+        parameters.canny_edge_upper_threshold,
+    )
+
+    # "Open" morphological operation
+    yield from set_using_group(pin_tip_detect_device.open_ksize, parameters.open_ksize)
+
+    # "Close" morphological operation
+    yield from set_using_group(
+        pin_tip_detect_device.close_ksize, parameters.close_ksize
+    )
+
+    # Sample detection direction
+    yield from set_using_group(
+        pin_tip_detect_device.scan_direction, parameters.direction
+    )
+
+    # Minimum height
+    yield from set_using_group(
+        pin_tip_detect_device.min_tip_height,
+        parameters.minimum_height,
+    )
+
+    if wait:
+        yield from bps.wait(group=group)

dodal/plans/preprocessors/verify_undulator_gap.py

@@ -9,18 +9,20 @@ def verify_undulator_gap_before_run_wrapper(
     devices: CheckUndulatorDevices,
     run_key_to_wrap: str | None = None,
 ):
-    """
-    Modifies the wrapped plan so that it checks the undulator gap before the specified run is opened and sets it to the correct value if needed.
+    """Modifies the wrapped plan so that it checks the undulator gap before
+        specified run is opened and sets it to the correct value if needed.
 
-    After a beam dump, the undulator gap may not return correctly, scientists have often requested that this check is done before collections.
+    After a beam dump, the undulator gap may not return correctly, scientists have often
+        requested that this check is done before collections.
 
     Args:
-        plan: The plan performing the run.
-        devices (CheckUndulatorDevices): Any device composite including the DCM and undulator
-        run_key_to_wrap: (str | None): The plan to verify the undulator gap is inserted after the 'open_run' message is seen with
-        the matching run key. If not specified, instead wrap the first run encountered.
+        plan (MsgGenerator): The plan performing the run.
+        devices (CheckUndulatorDevices): Any device composite including the DCM and
+            undulator.
+        run_key_to_wrap (str, optional): The plan to verify the undulator gap is
+            inserted after the 'open_run' message is seen with the matching run key. If
+            not specified, instead wrap the first run encountered.
     """
-
     # If no run_key specified, make sure we only do check on first run encountered
     _wrapped_run_name: None | str = None
 

dodal/plans/spec_path.py

@@ -48,18 +48,16 @@ def spec_scan(
 
 
 def _as_cycler(spec: Spec[Movable]) -> Cycler:
-    """
-    Convert a scanspec to a cycler for compatibility with legacy Bluesky plans such as
+    """Convert a scanspec to a cycler for compatibility with legacy Bluesky plans such as
     `bp.scan_nd`. Use the midpoints of the scanspec since cyclers are normally used
     for software triggered scans.
 
     Args:
-        spec: A scanspec
+        spec (Spec[Movable]): A scanspec.
 
     Returns:
-        Cycler: A new cycler
+        Cycler: A new cycler.
     """
-
     midpoints = spec.frames().midpoints
     # Need to "add" the cyclers for all the axes together. The code below is
     # effectively: cycler(motor1, [...]) + cycler(motor2, [...]) + ...

dodal/plans/verify_undulator_gap.py

@@ -13,7 +13,6 @@ class CheckUndulatorDevices(Protocol):
 
 
 def verify_undulator_gap(devices: CheckUndulatorDevices):
-    """Verify Undulator gap is correct - it may not be after a beam dump"""
-
+    """Verify Undulator gap is correct - it may not be after a beam dump."""
     energy_in_keV = yield from bps.rd(devices.dcm.energy_in_keV.user_readback)  # noqa: N806
     yield from bps.abs_set(devices.undulator, energy_in_keV, wait=True)

dodal/plans/wrapped.py

@@ -18,8 +18,8 @@ Non-serialisable fields are ignored when they are optional
 https://github.com/DiamondLightSource/blueapi/issues/711
 
 We may also need other adjustments for UI purposes, e.g.
-Forcing uniqueness or orderedness of Readables
-Limits and metadata (e.g. units)
+    - Forcing uniqueness or orderedness of Readables.
+    - Limits and metadata (e.g. units).
 """
 
 
@@ -47,7 +47,8 @@ def count(
 ) -> MsgGenerator:
     """Reads from a number of devices.
     Wraps bluesky.plans.count(det, num, delay, md=metadata) exposing only serializable
-    parameters and metadata."""
+    parameters and metadata.
+    """
     if isinstance(delay, Sequence):
         assert len(delay) == num - 1, (
             f"Number of delays given must be {num - 1}: was given {len(delay)}"

dodal/testing/electron_analyser/device_factory.py

@@ -14,14 +14,13 @@ def create_driver(
     driver_class: type[TAbstractAnalyserDriverIO],
     **kwargs: Any,
 ) -> TAbstractAnalyserDriverIO:
-    """
-    Helper function that helps to reduce the code to setup an analyser driver. The
+    """Helper function that helps to reduce the code to setup an analyser driver. The
     parameters used for the enum types are taken directly from the subscripts of the
     class so the user only needs to provide it in one place.
 
     Args:
         driver_class: The class for the driver which must include the enums in the
-                      subscript, for example MyDriverClass[MyLensMode, ...]
+            subscript, for example MyDriverClass[MyLensMode, ...].
         kwargs: Additional key worded arguments that the driver needs for initalisation.
     """
     parameters = {
@@ -38,16 +37,15 @@ def create_detector(
     detector_class: type[TElectronAnalyserDetector],
     **kwargs: Any,
 ) -> TElectronAnalyserDetector:
-    """
-    Helper function that helps to reduce the code to setup an analyser detector. The
+    """Helper function that helps to reduce the code to setup an analyser detector. The
     parameters used for the enum types are taken directly from the subscripts of the
     class so the user only needs to provide it in one place.
 
     Args:
         detector_class: The class for the detector which must include the enums in the
-                        subscript, for example MyDetectorClass[MyLensMode, ...]
+            subscript, for example MyDetectorClass[MyLensMode, ...].
         kwargs: Additional key worded arguments that the detector needs for
-                initalisation.
+            initalisation.
     """
     parameters = {
         "lens_mode_type": get_args(detector_class)[0],

dodal/testing/fixtures/devices/apple2.py

@@ -14,6 +14,10 @@ from dodal.devices.insertion_device import (
     UndulatorJawPhase,
     UndulatorPhaseAxes,
 )
+from dodal.devices.insertion_device.apple2_undulator import (
+    Apple2,
+    UndulatorLockedPhaseAxes,
+)
 
 
 @pytest.fixture
@@ -76,3 +80,37 @@ async def mock_jaw_phase(prefix: str = "BLXX-EA-DET-007:") -> UndulatorJawPhase:
     set_mock_value(mock_jaw_phase.jaw_phase.user_setpoint_readback, 0)
     set_mock_value(mock_jaw_phase.status, EnabledDisabledUpper.ENABLED)
     return mock_jaw_phase
+
+
+@pytest.fixture
+async def mock_locked_phase_axes(
+    prefix: str = "BLXX-EA-DET-007:",
+) -> UndulatorLockedPhaseAxes:
+    async with init_devices(mock=True):
+        mock_phase_axes = UndulatorLockedPhaseAxes(
+            prefix=prefix,
+            top_outer="RPQ1",
+            btm_inner="RPQ4",
+        )
+    assert mock_phase_axes.name == "mock_phase_axes"
+    set_mock_value(mock_phase_axes.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_phase_axes.top_outer.velocity, 2)
+    set_mock_value(mock_phase_axes.btm_inner.velocity, 2)
+    set_mock_value(mock_phase_axes.top_outer.user_readback, 2)
+    set_mock_value(mock_phase_axes.btm_inner.user_readback, 2)
+    set_mock_value(mock_phase_axes.top_outer.user_setpoint_readback, 2)
+    set_mock_value(mock_phase_axes.btm_inner.user_setpoint_readback, 2)
+    set_mock_value(mock_phase_axes.status, EnabledDisabledUpper.ENABLED)
+    return mock_phase_axes
+
+
+@pytest.fixture
+async def mock_locked_apple2(
+    mock_id_gap: UndulatorGap,
+    mock_locked_phase_axes: UndulatorLockedPhaseAxes,
+) -> Apple2[UndulatorLockedPhaseAxes]:
+    mock_locked_apple2 = Apple2[UndulatorLockedPhaseAxes](
+        id_gap=mock_id_gap,
+        id_phase=mock_locked_phase_axes,
+    )
+    return mock_locked_apple2

dodal/testing/fixtures/run_engine.py

@@ -1,6 +1,4 @@
-"""
-Allow external repos to reuse these fixtures so defined in single place.
-"""
+"""Allow external repos to reuse these fixtures so defined in single place."""
 
 import asyncio
 import copy
@@ -46,8 +44,7 @@ async def run_engine(_global_run_engine: RunEngine) -> AsyncGenerator[RunEngine,
 
 @pytest_asyncio.fixture(scope="session", loop_scope="session")
 async def _global_run_engine() -> AsyncGenerator[RunEngine, None]:
-    """
-    Obtain a run engine, with its own event loop and thread.
+    """Obtain a run engine, with its own event loop and thread.
 
     On closure of the scope, the run engine is stopped and the event loop closed
     in order to release all resources it consumes.
@@ -102,8 +99,7 @@ def run_engine_documents(run_engine: RunEngine) -> Mapping[str, list[dict]]:
 
 @pytest.fixture(autouse=_ENABLE_FILEHANDLE_LEAK_CHECKS)
 def check_for_filehandle_leaks(request: FixtureRequest):
-    """
-    Test fixture that can be enabled in order to check for leaked filehandles
+    """Test fixture that can be enabled in order to check for leaked filehandles
     (typically caused by a rogue RunEngine instance).
 
     Note that this test is not enabled by default due to imposing a significant

dodal/testing/fixtures/utils.py

@@ -9,8 +9,7 @@ import pytest
 
 @pytest.fixture
 async def event_loop_fuzzing():
-    """
-    This fixture can be used to try and detect / reproduce intermittent test failures
+    """This fixture can be used to try and detect / reproduce intermittent test failures
     caused by race conditions and timing issues, which are often difficult to replicate
     due to caching etc. causing timing to be different on a development machine compared
     to when the test runs in CI.