dls-dodal 1.53.0__py3-none-any.whl → 1.55.0__py3-none-any.whl

dodal/devices/i19/beamstop.py

@@ -6,7 +6,7 @@ from dodal.devices.motors import XYZStage
 
 class HomeGroup(StrictEnum):
     NONE = "none"
-    ALL = "All"
+    ALL = "ALL"
     X = "X"
     Y = "Y"
     Z = "Z"
@@ -23,4 +23,4 @@ class BeamStop(XYZStage):
     def __init__(self, prefix: str, name: str = "") -> None:
         self.homing = HomingControl(f"{prefix}HM", name)
 
-        super().__init__(name)
+        super().__init__(prefix, name)

dodal/devices/i24/aperture.py

@@ -22,4 +22,4 @@ class Aperture(XYStage):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.position = epics_signal_rw(AperturePositions, prefix + "MP:SELECT")
-        super().__init__(name)
+        super().__init__(prefix, name)

dodal/devices/motors.py

@@ -1,6 +1,8 @@
+import asyncio
+import math
 from abc import ABC
 
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, derived_signal_rw
 from ophyd_async.epics.motor import Motor
 
 _X, _Y, _Z = "X", "Y", "Z"
@@ -89,6 +91,25 @@ class XYPitchStage(XYStage):
         super().__init__(prefix, name, x_infix, y_infix)
 
 
+class XYZPitchYawRollStage(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        pitch_infix: str = "PITCH",
+        yaw_infix: str = "YAW",
+        roll_infix: str = "ROLL",
+    ):
+        with self.add_children_as_readables():
+            self.pitch = Motor(prefix + pitch_infix)
+            self.yaw = Motor(prefix + yaw_infix)
+            self.roll = Motor(prefix + roll_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
 class SixAxisGonio(XYZStage):
     def __init__(
         self,
@@ -101,12 +122,19 @@ class SixAxisGonio(XYZStage):
         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)
             self.omega = Motor(prefix + omega_infix)
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
+        self.vertical_in_lab_space = create_axis_perp_to_rotation(
+            self.omega, self.y, self.z
+        )
+
 
 class YZStage(Stage):
     def __init__(
@@ -116,3 +144,49 @@ class YZStage(Stage):
             self.y = Motor(prefix + y_infix)
             self.z = Motor(prefix + z_infix)
         super().__init__(name)
+
+
+def create_axis_perp_to_rotation(motor_theta: Motor, motor_i: Motor, motor_j: Motor):
+    """Given a signal that controls a motor in a rotation axis and two other
+    signals controlling motors on a pair of orthogonal axes, these axes being in the
+    rotating frame of reference created by the first axis, create a derived signal
+    that is a projection of the two axes in the non-rotating frame of reference.
+
+    The projection is onto the axis defined by i when the rotation angle is 0 and
+    defined by j when the angle is at 90.
+
+    The usual use case for this is translating from sample space to lab space. For
+    example, if you have a sample that is mounted on a goniometer to the right hand side
+    of an OAV view this can provide an axis that will move the sample up/down in that
+    view regardless of the omega orientation of the sample.
+
+    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.
+        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.
+    """
+
+    def _get(j_val: float, i_val: float, rot_value: float) -> float:
+        i_component = i_val * math.cos(math.radians(rot_value))
+        j_component = j_val * math.sin(math.radians(rot_value))
+        return i_component + j_component
+
+    async def _set(vertical_value: float) -> None:
+        rot_value = await motor_theta.user_readback.get_value()
+        i_component = vertical_value * math.cos(math.radians(rot_value))
+        j_component = vertical_value * math.sin(math.radians(rot_value))
+        await asyncio.gather(
+            motor_i.set(i_component),
+            motor_j.set(j_component),
+            motor_theta.set(rot_value),
+        )
+
+    return derived_signal_rw(
+        _get,
+        _set,
+        i_val=motor_i,
+        j_val=motor_j,
+        rot_value=motor_theta,
+    )

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -110,11 +110,11 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
         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"""
         jpeg_bytes = await get_next_jpeg(response)
-        self.uuid_setter(redis_uuid)
         sample_id = await self.sample_id.get_value()
         redis_key = f"murko:{sample_id}:raw"
         await self.redis_client.hset(redis_key, redis_uuid, jpeg_bytes)  # type: ignore
         await self.redis_client.expire(redis_key, timedelta(days=self.DATA_EXPIRY_DAYS))
+        self.uuid_setter(redis_uuid)
 
     async def _open_connection_and_do_function(
         self, function_to_do: Callable[[ClientResponse, OAVSource], Awaitable]

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -1,4 +1,3 @@
-import asyncio
 import time
 
 import numpy as np
@@ -160,7 +159,7 @@ class PinTipDetection(StandardReadable):
                     )
                 else:
                     break
-        except asyncio.exceptions.TimeoutError:
+        except TimeoutError:
             LOGGER.error(
                 f"No tip found in {await self.validity_timeout.get_value()} seconds."
             )

dodal/devices/p60/__init__.py

@@ -1,4 +1,10 @@
-from .enums import LensMode
+from .enums import LensMode, PassEnergy, PsuMode
 from .lab_xray_source import LabXraySource, LabXraySourceReadable
 
-__all__ = ["LensMode", "LabXraySource", "LabXraySourceReadable"]
+__all__ = [
+    "LensMode",
+    "PsuMode",
+    "PassEnergy",
+    "LabXraySource",
+    "LabXraySourceReadable",
+]

dodal/devices/p60/enums.py

@@ -8,3 +8,19 @@ class LensMode(StrictEnum):
     ANGULAR30 = "Angular30"
     ANGULAR30_SMALLSPOT = "Angular30_SmallSpot"
     ANGULAR14_SMALLSPOT = "Angular14_SmallSpot"
+
+
+class PsuMode(StrictEnum):
+    HIGH = "High Pass (XPS)"
+    LOW = "Low Pass (UPS)"
+
+
+class PassEnergy(StrictEnum):
+    E1 = 1
+    E2 = 2
+    E5 = 5
+    E10 = 10
+    E20 = 20
+    E50 = 50
+    E100 = 100
+    E200 = 200

dodal/devices/robot.py

@@ -21,6 +21,9 @@ from ophyd_async.epics.core import (
 
 from dodal.log import LOGGER
 
+WAIT_FOR_OLD_PIN_MSG = "Waiting on old pin unloaded"
+WAIT_FOR_NEW_PIN_MSG = "Waiting on new pin loaded"
+
 
 class RobotLoadFailed(Exception):
     error_code: int
@@ -74,7 +77,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
     # How far the gonio position can be out before loading will fail
     LOAD_TOLERANCE_MM = 0.02
 
-    def __init__(self, name: str, prefix: str) -> None:
+    def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.barcode = epics_signal_r(str, prefix + "BARCODE")
             self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
@@ -144,6 +147,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
             # in the current task, when it propagates to here we should cancel all pending tasks before bubbling up
             for task in tasks:
                 task.cancel()
+
             raise
 
     async def _load_pin_and_puck(self, sample_location: SampleLocation):
@@ -164,9 +168,9 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         )
         await self.load.trigger()
         if await self.gonio_pin_sensor.get_value() == PinMounted.PIN_MOUNTED:
-            LOGGER.info("Waiting on old pin unloaded")
+            LOGGER.info(WAIT_FOR_OLD_PIN_MSG)
             await wait_for_value(self.gonio_pin_sensor, PinMounted.NO_PIN_MOUNTED, None)
-        LOGGER.info("Waiting on new pin loaded")
+        LOGGER.info(WAIT_FOR_NEW_PIN_MSG)
 
         await self.pin_mounted_or_no_pin_found()
 
@@ -178,7 +182,6 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
                 timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
             )
         except TimeoutError as e:
-            # Will only need to catch asyncio.TimeoutError after https://github.com/bluesky/ophyd-async/issues/572
             await self.prog_error.raise_if_error(e)
             await self.controller_error.raise_if_error(e)
             raise RobotLoadFailed(0, "Robot timed out") from e

dodal/devices/tetramm.py

@@ -22,9 +22,8 @@ from ophyd_async.epics.adcore import (
     NDArrayBaseIO,
     NDFileHDFIO,
     NDPluginBaseIO,
-    stop_busy_record,
 )
-from ophyd_async.epics.core import PvSuffix
+from ophyd_async.epics.core import PvSuffix, stop_busy_record
 
 
 class TetrammRange(StrictEnum):

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,

dodal/utils.py

@@ -426,16 +426,9 @@ def is_v2_device_type(obj: type[Any]) -> bool:
             # This is all very badly documented and possibly prone to change in future versions of Python
             non_parameterized_class = obj.__origin__
         if non_parameterized_class:
-            try:
-                return non_parameterized_class and issubclass(
-                    non_parameterized_class, OphydV2Device
-                )
-            except TypeError:
-                # Python 3.10 will return inspect.isclass(t) == True but then
-                # raise TypeError: issubclass() arg 1 must be a class
-                # when inspecting device_factory decorator function itself
-                # Later versions of Python seem not to be affected
-                pass
+            return non_parameterized_class and issubclass(
+                non_parameterized_class, OphydV2Device
+            )
 
     return False