dls-dodal 1.54.0__py3-none-any.whl → 1.55.1__py3-none-any.whl

dodal/devices/tetramm.py

@@ -116,6 +116,19 @@ class TetrammController(DetectorController):
             self.set_exposure(trigger_info.livetime),
         )
 
+        # raise an error if asked to trigger faster than the max.
+        # possible speed for a tetramm
+        self._validate_deadtime(trigger_info)
+
+    def _validate_deadtime(self, value: TriggerInfo) -> None:
+        minimum_deadtime = self.get_deadtime(value.livetime)
+        if minimum_deadtime > value.deadtime:
+            msg = (
+                f"Tetramm {self} needs at least {minimum_deadtime}s "
+                f"deadtime, but trigger logic provides only {value.deadtime}s"
+            )
+            raise ValueError(msg)
+
     async def arm(self):
         self._arm_status = await self.start_acquiring_driver_and_ensure_status()
 

dodal/devices/util/test_utils.py

@@ -1,3 +1,6 @@
+from contextlib import ExitStack
+
+from ophyd_async.core import Device
 from ophyd_async.epics.motor import Motor
 from ophyd_async.testing import (
     callback_on_mock_put,
@@ -16,3 +19,19 @@ def patch_motor(motor: Motor, initial_position=0):
         motor.user_setpoint,
         lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),
     )
+
+
+def patch_all_motors(parent_device: Device):
+    motors = []
+
+    def recursively_find_motors(device: Device):
+        for _, child_device in device.children():
+            if isinstance(child_device, Motor):
+                motors.append(child_device)
+            recursively_find_motors(child_device)
+
+    recursively_find_motors(parent_device)
+    motor_patch_stack = ExitStack()
+    for motor in motors:
+        motor_patch_stack.enter_context(patch_motor(motor))
+    return motor_patch_stack

dodal/devices/webcam.py

@@ -12,6 +12,7 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 from PIL import Image
+from yarl import URL
 
 from dodal.log import LOGGER
 
@@ -26,7 +27,7 @@ def create_placeholder_image() -> ByteString:
 
 
 class Webcam(StandardReadable, Triggerable):
-    def __init__(self, name, prefix, url):
+    def __init__(self, url: URL, name: str = ""):
         self.url = url
         self.filename = soft_signal_rw(str, name="filename")
         self.directory = soft_signal_rw(str, name="directory")

dodal/devices/zebra/zebra.py

@@ -286,7 +286,7 @@ class SoftInputs(StandardReadable):
 class Zebra(StandardReadable):
     """The Zebra device."""
 
-    def __init__(self, mapping: ZebraMapping, name: str, prefix: str) -> None:
+    def __init__(self, mapping: ZebraMapping, prefix: str, name: str = "") -> None:
         self.mapping = mapping
         self.pc = PositionCompare(prefix, name)
         self.output = ZebraOutputPanel(prefix, name)

dodal/devices/zebra/zebra_controlled_shutter.py

@@ -28,7 +28,7 @@ class ZebraShutter(StandardReadable, Movable[ZebraShutterState]):
     by a different soft input (aliased to manual_position_setpoint). Both these AND
     gates then feed into an OR gate, which then feeds to the shutter."""
 
-    def __init__(self, prefix: str, name: str):
+    def __init__(self, prefix: str, name: str = ""):
         self._manual_position_setpoint = epics_signal_w(
             ZebraShutterState, prefix + "CTRL2"
         )

dodal/devices/zocalo/__init__.py

@@ -4,6 +4,7 @@ from dodal.devices.zocalo.zocalo_results import (
     NoZocaloSubscription,
     XrcResult,
     ZocaloResults,
+    ZocaloSource,
     get_full_processing_results,
 )
 
@@ -15,4 +16,5 @@ __all__ = [
     "NoResultsFromZocalo",
     "NoZocaloSubscription",
     "ZocaloStartInfo",
+    "ZocaloSource",
 ]

dodal/devices/zocalo/zocalo_results.py

@@ -119,8 +119,7 @@ class ZocaloResults(StandardReadable, Triggerable):
 
         prefix (str): EPICS PV prefix for the device
 
-        use_gpu (bool): When True, ZocaloResults will take the first set of
-        results that it receives (which are likely the GPU results)
+        results_source (ZocaloSource): Where to get results from, GPU or CPU analysis
 
     """
 
@@ -132,7 +131,7 @@ class ZocaloResults(StandardReadable, Triggerable):
         sort_key: str = DEFAULT_SORT_KEY.value,
         timeout_s: float = DEFAULT_TIMEOUT,
         prefix: str = "",
-        use_gpu: bool = False,
+        results_source: ZocaloSource = ZocaloSource.CPU,
     ) -> None:
         self.zocalo_environment = zocalo_environment
         self.sort_key = SortKeys[sort_key]
@@ -141,7 +140,7 @@ class ZocaloResults(StandardReadable, Triggerable):
         self._prefix = prefix
         self._raw_results_received: Queue = Queue()
         self.transport: CommonTransport | None = None
-        self.use_gpu = use_gpu
+        self.results_source = results_source
 
         self.centre_of_mass, self._com_setter = soft_signal_r_and_setter(
             Array1D[np.float64], name="centre_of_mass"
@@ -237,9 +236,6 @@ class ZocaloResults(StandardReadable, Triggerable):
             "meant for it"
         )
         if not self.transport:
-            LOGGER.warning(
-                msg  # AsyncStatus exception messages are poorly propagated, remove after https://github.com/bluesky/ophyd-async/issues/103
-            )
             raise NoZocaloSubscription(msg)
 
         try:
@@ -247,16 +243,19 @@ class ZocaloResults(StandardReadable, Triggerable):
                 f"waiting for results in queue - currently {self._raw_results_received.qsize()} items"
             )
 
-            raw_results = self._raw_results_received.get(timeout=self.timeout_s)
-            source_of_first_results = source_from_results(raw_results)
+            while True:
+                raw_results = self._raw_results_received.get(timeout=self.timeout_s)
+                source_of_results = source_from_results(raw_results)
 
-            if self.use_gpu and source_of_first_results == ZocaloSource.CPU:
-                LOGGER.warning(
-                    "Configured to use GPU results but CPU came first, using CPU results."
-                )
+                if source_of_results != self.results_source:
+                    LOGGER.warning(
+                        f"Configured to use {self.results_source} results but {source_of_results} came first, waiting for further results."
+                    )
+                else:
+                    break
 
             LOGGER.info(
-                f"Zocalo results from {source_from_results(raw_results)} processing: found {len(raw_results['results'])} crystals."
+                f"Zocalo results: found {len(raw_results['results'])} crystals."
             )
             # Sort from strongest to weakest in case of multiple crystals
             await self._put_results(
@@ -288,18 +287,9 @@ class ZocaloResults(StandardReadable, Triggerable):
 
             results = message.get("results", [])
 
-            if self.use_gpu:
-                self._raw_results_received.put(
-                    {"results": results, "recipe_parameters": recipe_parameters}
-                )
-            else:
-                # Only add to queue if results are from CPU
-                if not recipe_parameters.get("gpu"):
-                    self._raw_results_received.put(
-                        {"results": results, "recipe_parameters": recipe_parameters}
-                    )
-                else:
-                    LOGGER.warning("Discarding results as they are from GPU")
+            self._raw_results_received.put(
+                {"results": results, "recipe_parameters": recipe_parameters}
+            )
 
         subscription = workflows.recipe.wrap_subscribe(
             self.transport,