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

dodal/devices/scintillator.py

@@ -69,6 +69,10 @@ class Scintillator(StandardReadable):
     async def _set_selected_position(self, position: InOut) -> None:
         match position:
             case InOut.OUT:
+                current_y = await self.y_mm.user_readback.get_value()
+                current_z = await self.z_mm.user_readback.get_value()
+                if self._get_selected_position(current_y, current_z) == InOut.OUT:
+                    return
                 if (
                     self._aperture_scatterguard().selected_aperture.get_value()
                     != ApertureValue.PARKED

dodal/devices/undulator.py

@@ -1,7 +1,7 @@
 import os
 
 import numpy as np
-from bluesky.protocols import Movable
+from bluesky.protocols import Locatable, Location, Movable
 from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
@@ -9,6 +9,7 @@ from ophyd_async.core import (
     StandardReadable,
     StandardReadableFormat,
     soft_signal_r_and_setter,
+    soft_signal_rw,
 )
 from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
@@ -157,3 +158,30 @@ class Undulator(StandardReadable, Movable[float]):
             energy_kev * 1000,
             energy_to_distance_table,
         )
+
+
+class UndulatorOrder(StandardReadable, Locatable[int]):
+    """
+    Represents the order of an undulator device. Allows setting and locating the order.
+    """
+
+    def __init__(self, name: str = "") -> None:
+        """
+        Args:
+            name: Name for device. Defaults to ""
+        """
+        with self.add_children_as_readables():
+            self._value = soft_signal_rw(int, initial_value=3)
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: int) -> None:
+        if (value >= 0) and isinstance(value, int):
+            await self._value.set(value)
+        else:
+            raise ValueError(
+                f"Undulator order must be a positive integer. Requested value: {value}"
+            )
+
+    async def locate(self) -> Location[int]:
+        return await self._value.locate()

dodal/devices/util/lookup_tables.py

@@ -13,13 +13,19 @@ from numpy import interp, loadtxt
 from dodal.log import LOGGER
 
 
-async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
+async def energy_distance_table(
+    lookup_table_path: str,
+    comments: Sequence[str] = ["#", "Units"],
+    skiprows: int = 0,
+) -> np.ndarray:
     """
     Returns a numpy formatted lookup table for required positions of an ID gap to
     provide emission at a given beam energy.
 
     Args:
         lookup_table_path: Path to lookup table
+        comments: Lines starting with any of these strings will be ignored
+        skiprows: Number of rows to skip at the start of the file
 
     Returns:
         ndarray: Lookup table
@@ -29,7 +35,7 @@ async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
     # decodes the text
     async with aiofiles.open(lookup_table_path) as stream:
         raw_table = await stream.read()
-    return loadtxt(StringIO(raw_table), comments=["#", "Units"])
+    return loadtxt(StringIO(raw_table), comments=comments, skiprows=skiprows)
 
 
 def parse_lookup_table(filename: str) -> list[Sequence]:

dodal/plan_stubs/__init__.py

@@ -0,0 +1,3 @@
+from .wrapped import move, move_relative, set_absolute, set_relative, sleep, wait
+
+__all__ = ["move", "move_relative", "set_absolute", "set_relative", "sleep", "wait"]

dodal/plans/verify_undulator_gap.py

@@ -15,5 +15,5 @@ class CheckUndulatorDevices(Protocol):
 def verify_undulator_gap(devices: CheckUndulatorDevices):
     """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)
-    yield from bps.abs_set(devices.undulator, energy_in_kev, wait=True)
+    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/testing/fixtures/run_engine.py

@@ -0,0 +1,118 @@
+"""
+Allow external repos to reuse these fixtures so defined in single place.
+"""
+
+import asyncio
+import os
+import threading
+import time
+from collections.abc import AsyncGenerator, Mapping
+
+import pytest
+import pytest_asyncio
+from _pytest.fixtures import FixtureRequest
+from bluesky.run_engine import RunEngine
+from bluesky.simulators import RunEngineSimulator
+
+_run_engine = RunEngine()
+
+_ENABLE_FILEHANDLE_LEAK_CHECKS = (
+    os.getenv("DODAL_ENABLE_FILEHANDLE_LEAK_CHECKS", "").lower() == "true"
+)
+
+
+@pytest_asyncio.fixture(scope="session", loop_scope="session", autouse=True)
+async def _ensure_running_bluesky_event_loop(_global_run_engine):
+    # make sure the event loop is thoroughly up and running before we try to create
+    # any ophyd_async devices which might need it
+    timeout = time.monotonic() + 1
+    while not _global_run_engine.loop.is_running():
+        await asyncio.sleep(0)
+        if time.monotonic() > timeout:
+            raise TimeoutError("This really shouldn't happen but just in case...")
+
+
+@pytest.fixture()
+async def run_engine(_global_run_engine: RunEngine) -> AsyncGenerator[RunEngine, None]:
+    try:
+        yield _global_run_engine
+    finally:
+        _global_run_engine.reset()
+
+
+@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.
+
+    On closure of the scope, the run engine is stopped and the event loop closed
+    in order to release all resources it consumes.
+    """
+    run_engine = RunEngine({}, call_returns_result=True)
+    yield run_engine
+    try:
+        run_engine.halt()
+    except Exception as e:
+        # Ignore exception thrown if the run engine is already halted.
+        print(f"Got exception while halting RunEngine {e}")
+    finally:
+
+        async def get_event_loop_thread():
+            """Get the thread which the run engine created for the event loop."""
+            return threading.current_thread()
+
+        fut = asyncio.run_coroutine_threadsafe(get_event_loop_thread(), run_engine.loop)
+        while not fut.done():
+            # It's not clear why this is necessary, given we are
+            # on a completely different thread and event loop
+            # but without it our future never seems to be populated with a result
+            # despite the coro getting executed
+            await asyncio.sleep(0)
+        # Terminate the event loop so that we can join() the thread
+        run_engine.loop.call_soon_threadsafe(run_engine.loop.stop)
+        run_engine_thread = fut.result()
+        run_engine_thread.join()
+        # This closes the filehandle in the event loop.
+        # This cannot be called while the event loop is running
+        run_engine.loop.close()
+    del run_engine
+
+
+@pytest.fixture
+def sim_run_engine() -> RunEngineSimulator:
+    return RunEngineSimulator()
+
+
+@pytest.fixture
+def run_engine_documents(run_engine: RunEngine) -> Mapping[str, list[dict]]:
+    docs: dict[str, list[dict]] = {}
+
+    def append_and_print(name, doc):
+        if name not in docs:
+            docs[name] = []
+        docs[name] += [doc]
+
+    run_engine.subscribe(append_and_print)
+    return docs
+
+
+@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
+    (typically caused by a rogue RunEngine instance).
+
+    Note that this test is not enabled by default due to imposing a significant
+    overhead. When a leak is suspected, usually from seeing a
+    PytestUnraisableExceptionWarning, enable this via autouse and run the full
+    test suite.
+    """
+    pid = os.getpid()
+    _baseline_n_open_files = len(os.listdir(f"/proc/{pid}/fd"))
+    try:
+        yield
+    finally:
+        _n_open_files = len(os.listdir(f"/proc/{pid}/fd"))
+        assert _n_open_files == _baseline_n_open_files, (
+            f"Function {request.function.__name__} leaked some filehandles"
+        )

dodal/testing/fixtures/utils.py

@@ -0,0 +1,57 @@
+import asyncio
+import threading
+import time
+from random import random
+from threading import Thread
+
+import pytest
+
+
+@pytest.fixture
+async def event_loop_fuzzing():
+    """
+    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.
+
+    It works by attaching a fuzzer to the current event loop which randomly schedules
+    a fixed delay into the event loop thread every few milliseconds. The idea is that
+    over a number of iterations, there should be sufficient timing variation introduced
+    that the failure can be reproduced.
+
+    Examples:
+        Example usage:
+    >>> import pytest
+    >>> # repeat the test a number of times
+    >>> @pytest.mark.parametrize("i", range(0, 100))
+    ... async def my_unreliable_test(i, event_loop_fuzzing):
+    ...     # Do some stuff in here
+    ...     ...
+    """
+    fuzz_probability = 0.05
+    fuzz_delay_s = 0.05
+    fuzz_period_s = 0.001
+    stop_running = threading.Event()
+    event_loop = asyncio.get_running_loop()
+
+    def delay(finished_event: threading.Event):
+        time.sleep(fuzz_delay_s)  # noqa: TID251
+        finished_event.set()
+
+    def fuzz():
+        while not stop_running.is_set():
+            if random() < fuzz_probability:
+                delay_is_finished = threading.Event()
+                event_loop.call_soon_threadsafe(delay, delay_is_finished)
+                delay_is_finished.wait()
+
+            time.sleep(fuzz_period_s)  # noqa: TID251
+
+    fuzzer_thread = Thread(group=None, target=fuzz, name="Event loop fuzzer")
+    fuzzer_thread.start()
+    try:
+        yield None
+    finally:
+        stop_running.set()
+        fuzzer_thread.join()