dls-dodal 1.62.0__py3-none-any.whl → 1.64.0__py3-none-any.whl

dodal/testing/fixtures/run_engine.py

@@ -0,0 +1,46 @@
+"""
+Allow external repos to reuse these fixtures so defined in single place.
+"""
+
+import asyncio
+import time
+from collections.abc import Mapping
+
+import pytest
+from bluesky.run_engine import RunEngine
+from bluesky.simulators import RunEngineSimulator
+
+
+@pytest.fixture(scope="session", autouse=True)
+async def _ensure_running_bluesky_event_loop():
+    run_engine = RunEngine()
+    # 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 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():
+    yield RunEngine()
+
+
+@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

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()

dls_dodal-1.62.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-dodal = dodal.__main__:main
-save-panda = dodal.devices.util.save_panda:main

dodal/beamlines/i10-1.py

@@ -1,25 +0,0 @@
-from dodal.common.beamlines.beamline_utils import (
-    device_factory,
-)
-from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.synchrotron import Synchrotron
-from dodal.devices.temperture_controller import Lakeshore336
-from dodal.log import set_beamline as set_log_beamline
-from dodal.utils import BeamlinePrefix, get_beamline_name
-
-BL = get_beamline_name("i10-1")
-PREFIX = BeamlinePrefix(BL, suffix="J")
-set_log_beamline(BL)
-set_utils_beamline(BL)
-
-
-@device_factory()
-def synchrotron() -> Synchrotron:
-    return Synchrotron()
-
-
-@device_factory()
-def em_temperature_controller() -> Lakeshore336:
-    return Lakeshore336(
-        prefix=f"{PREFIX.beamline_prefix}-EA-TCTRL-41:",
-    )

dodal/devices/i09/dcm.py

@@ -1,26 +0,0 @@
-from ophyd_async.core import derived_signal_r
-
-from dodal.devices.common_dcm import BaseDCM, PitchAndRollCrystal, StationaryCrystal
-
-
-class DCM(BaseDCM[PitchAndRollCrystal, StationaryCrystal]):
-    """
-    I09 double crystal monochromator (DCM), used to select the energy of the beam.
-    Differences:
-
-    1. Can provide energy in eV via dcm.energy_in_ev read signal
-
-    This DCM is available on i09 and i09_1 endstations.
-    """
-
-    def __init__(self, prefix: str, name: str = "") -> None:
-        super().__init__(prefix, PitchAndRollCrystal, StationaryCrystal, name)
-        self.energy_in_ev = derived_signal_r(
-            self._convert_keV_to_eV, energy_signal=self.energy_in_kev.user_readback
-        )
-        # Set name so that new child signals get correct name
-        # need to do it until https://github.com/bluesky/ophyd-async/pull/899 merged
-        self.set_name(self.name)
-
-    def _convert_keV_to_eV(self, energy_signal: float) -> float:
-        return energy_signal * 1000