dls-dodal 1.29.3__py3-none-any.whl → 1.30.0__py3-none-any.whl

dodal/devices/i22/nxsas.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass, fields
-from typing import Dict
 
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
@@ -13,7 +12,7 @@ ValueAndUnits = tuple[float, str]
 @dataclass
 class MetadataHolder:
     # TODO: just in case this is useful more widely...
-    async def describe(self, parent_name: str) -> Dict[str, DataKey]:
+    async def describe(self, parent_name: str) -> dict[str, DataKey]:
         def datakey(value) -> DataKey:
             if isinstance(value, tuple):
                 return {"units": value[1], **datakey(value[0])}
@@ -40,8 +39,8 @@ class MetadataHolder:
             if getattr(self, field.name, None) is not None
         }
 
-    async def read(self, parent_name: str) -> Dict[str, Reading]:
-        def reading(value):
+    async def read(self, parent_name: str) -> dict[str, Reading]:
+        def reading(value) -> Reading:
             if isinstance(value, tuple):
                 return reading(value[0])
             return {"timestamp": -1, "value": value}
@@ -101,25 +100,21 @@ class NXSasPilatus(PilatusDetector):
         )
         self._metadata_holder = metadata_holder
 
-    async def read_configuration(self) -> Dict[str, Reading]:
+    async def read_configuration(self) -> dict[str, Reading]:
         return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().read_configuration(),
-                    self._metadata_holder.read(self.name),
-                )
+            r
+            for r in (
+                super().read_configuration(),
+                self._metadata_holder.read(self.name),
             )
         )
 
-    async def describe_configuration(self) -> Dict[str, DataKey]:
+    async def describe_configuration(self) -> dict[str, DataKey]:
         return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().describe_configuration(),
-                    self._metadata_holder.describe(self.name),
-                )
+            r
+            for r in (
+                super().describe_configuration(),
+                self._metadata_holder.describe(self.name),
             )
         )
 
@@ -150,24 +145,20 @@ class NXSasOAV(AravisDetector):
         )
         self._metadata_holder = metadata_holder
 
-    async def read_configuration(self) -> Dict[str, Reading]:
+    async def read_configuration(self) -> dict[str, Reading]:
         return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().read_configuration(),
-                    self._metadata_holder.read(self.name),
-                )
+            r
+            for r in (
+                super().read_configuration(),
+                self._metadata_holder.read(self.name),
             )
         )
 
-    async def describe_configuration(self) -> Dict[str, DataKey]:
+    async def describe_configuration(self) -> dict[str, DataKey]:
         return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().describe_configuration(),
-                    self._metadata_holder.describe(self.name),
-                )
+            r
+            for r in (
+                super().describe_configuration(),
+                self._metadata_holder.describe(self.name),
             )
         )

dodal/devices/i24/dcm.py

@@ -0,0 +1,42 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.signal import epics_signal_r
+
+
+class DCM(StandardReadable):
+    """
+    A double crystal monocromator device, used to select the beam energy.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            # Motors
+            self.bragg_in_degrees = Motor(prefix + "-MO-DCM-01:BRAGG")
+            self.x_translation_in_mm = Motor(prefix + "-MO-DCM-01:X")
+            self.offset_in_mm = Motor(prefix + "-MO-DCM-01:OFFSET")
+            self.gap_in_mm = Motor(prefix + "-MO-DCM-01:GAP")
+            self.energy_in_kev = Motor(prefix + "-MO-DCM-01:ENERGY")
+            self.xtal1_roll = Motor(prefix + "-MO-DCM-01:XTAL1:ROLL")
+            self.xtal2_roll = Motor(prefix + "-MO-DCM-01:XTAL2:ROLL")
+            self.xtal2_pitch = Motor(prefix + "-MO-DCM-01:XTAL2:PITCH")
+
+            # Wavelength is calculated in epics from the energy
+            self.wavelength_in_a = epics_signal_r(float, prefix + "-MO-DCM-01:LAMBDA")
+
+            # Temperatures
+            self.xtal1_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-1")
+            self.xtal1_heater_temp = epics_signal_r(
+                float, prefix + "-DI-DCM-01:PT100-2"
+            )
+            self.xtal2_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-4")
+            self.xtal2_heater_temp = epics_signal_r(
+                float, prefix + "-DI-DCM-01:PT100-5"
+            )
+
+            self.roll_plate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-3")
+            self.pitch_plate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-6")
+            self.backplate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-7")
+            self.b1_plate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-7")
+            self.gap_temp = epics_signal_r(float, prefix + "-DI-DCM-01:TC-1")
+
+        super().__init__(name)

dodal/devices/i24/pmac.py

@@ -1,8 +1,9 @@
-from enum import Enum
+from enum import Enum, IntEnum
+from typing import SupportsFloat
 
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.core.signal import SignalRW
+from ophyd_async.core import AsyncStatus, StandardReadable, wait_for_value
+from ophyd_async.core.signal import CalculateTimeout, SignalR, SignalRW
 from ophyd_async.core.signal_backend import SignalBackend
 from ophyd_async.core.soft_signal_backend import SoftSignalBackend
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
@@ -13,6 +14,11 @@ HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
 
 
+class ScanState(IntEnum):
+    RUNNING = 1
+    DONE = 0
+
+
 class LaserSettings(str, Enum):
     """PMAC strings to switch laser on and off.
     Note. On the PMAC, M-variables usually have to do with position compare
@@ -73,26 +79,55 @@ class PMACStringLaser(SignalRW):
         super().__init__(backend, timeout, name)
 
     @AsyncStatus.wrap
-    async def set(self, laser_setting: LaserSettings):
-        await self.signal.set(laser_setting.value, wait=True)
+    async def set(self, value: LaserSettings, wait=True, timeout=CalculateTimeout):
+        await self.signal.set(value.value, wait, timeout)
 
 
 class PMACStringEncReset(SignalRW):
-    """"""
+    """Set a pmac_string to control the encoder channels in the controller."""
+
+    def __init__(
+        self,
+        pmac_str_sig: SignalRW,
+        backend: SignalBackend,
+        timeout: float | None = DEFAULT_TIMEOUT,
+        name: str = "",
+    ) -> None:
+        self.signal = pmac_str_sig
+        super().__init__(backend, timeout, name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: EncReset, wait=True, timeout=CalculateTimeout):
+        await self.signal.set(value.value, wait, timeout)
+
+
+class ProgramRunner(SignalRW):
+    """Trigger the collection by setting the program number on the PMAC string.
+
+    Once the program number has been set, wait for the collection to be complete.
+    This will only be true when the status becomes 0.
+    """
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
+        status_sig: SignalR,
         backend: SignalBackend,
         timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
         self.signal = pmac_str_sig
+        self.status = status_sig
         super().__init__(backend, timeout, name)
 
     @AsyncStatus.wrap
-    async def set(self, enc_string: EncReset):
-        await self.signal.set(enc_string.value, wait=True)
+    async def set(self, value: int, wait=True, timeout=None):
+        prog_str = f"&2b{value}r"
+        assert isinstance(timeout, SupportsFloat) or (
+            timeout is None
+        ), f"ProgramRunner does not support calculating timeout itself, {timeout=}"
+        await self.signal.set(prog_str, wait=wait)
+        await wait_for_value(self.status, ScanState.DONE, timeout)
 
 
 class PMAC(StandardReadable):
@@ -121,4 +156,8 @@ class PMAC(StandardReadable):
         self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
         self.counter = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2402")
 
+        self.run_program = ProgramRunner(
+            self.pmac_string, self.scanstatus, backend=SoftSignalBackend(str)
+        )
+
         super().__init__(name)

dodal/devices/ipin.py

@@ -1,8 +1,11 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignalRO, Kind
+from ophyd_async.core import HintedSignal, StandardReadable
+from ophyd_async.epics.signal import epics_signal_r
 
 
-class IPin(Device):
+class IPin(StandardReadable):
     """Simple device to get the ipin reading"""
 
-    reading = Cpt(EpicsSignalRO, "I", kind=Kind.hinted)
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(wrapper=HintedSignal):
+            self.pin_readback = epics_signal_r(float, prefix + "I")
+        super().__init__(name)

dodal/devices/linkam3.py

@@ -1,10 +1,15 @@
 import asyncio
 import time
 from enum import Enum
-from typing import Optional
 
 from bluesky.protocols import Location
-from ophyd_async.core import StandardReadable, WatchableAsyncStatus, observe_value
+from ophyd_async.core import (
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    observe_value,
+)
 from ophyd_async.core.utils import WatcherUpdate
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
@@ -57,14 +62,15 @@ class Linkam3(StandardReadable):
         # status is a bitfield stored in a double?
         self.status = epics_signal_r(float, prefix + "STATUS:")
 
-        self.set_readable_signals(
-            read=(self.temp,), config=(self.ramp_rate, self.speed, self.set_point)
+        self.add_readables((self.temp,), wrapper=HintedSignal)
+        self.add_readables(
+            (self.ramp_rate, self.speed, self.set_point), wrapper=ConfigSignal
         )
 
         super().__init__(name=name)
 
     @WatchableAsyncStatus.wrap
-    async def set(self, new_position: float, timeout: Optional[float] = None):
+    async def set(self, new_position: float, timeout: float | None = None):
         # time.monotonic won't go backwards in case of NTP corrections
         start = time.monotonic()
         old_position = await self.set_point.get_value()

dodal/devices/logging_ophyd_device.py

@@ -3,7 +3,7 @@ from ophyd.log import logger as ophyd_logger
 
 
 class InfoLoggingDevice(Device):
-    def wait_for_connection(self, all_signals=False, timeout=2):
+    def wait_for_connection(self, all_signals=False, timeout=2.0):
         class_name = self.__class__.__name__
         ophyd_logger.info(
             f"{class_name} waiting for connection, {'not' if all_signals else ''} waiting for all signals, timeout = {timeout}s.",

dodal/devices/motors.py

@@ -3,8 +3,34 @@ from ophyd_async.epics.motion import Motor
 
 
 class XYZPositioner(Device):
-    def __init__(self, prefix: str, name: str):
-        self.x = Motor(prefix + "X")
-        self.y = Motor(prefix + "Y")
-        self.z = Motor(prefix + "Z")
-        super().__init__(name)
+    """
+
+    Standard ophyd_async xyz motor stage, by combining 3 Motors,
+    with added infix for extra flexibliy to allow different axes other than x,y,z.
+
+    Parameters
+    ----------
+    prefix:
+        EPICS PV (Common part up to and including :).
+    name:
+        name for the stage.
+    infix:
+        EPICS PV, default is the ["X", "Y", "Z"].
+    Notes
+    -----
+    Example usage::
+        async with DeviceCollector():
+            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:")
+    Or::
+        with DeviceCollector():
+            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:", suffix = ["A", "B", "C"])
+
+    """
+
+    def __init__(self, prefix: str, name: str, infix: list[str] | None = None):
+        if infix is None:
+            infix = ["X", "Y", "Z"]
+        self.x = Motor(prefix + infix[0])
+        self.y = Motor(prefix + infix[1])
+        self.z = Motor(prefix + infix[2])
+        super().__init__(name=name)

dodal/devices/oav/grid_overlay.py

@@ -1,3 +1,4 @@
+# type: ignore # OAV will soon be ophyd-async, see https://github.com/DiamondLightSource/dodal/issues/716
 from enum import Enum
 from functools import partial
 from os.path import join as path_join

dodal/devices/oav/microns_for_zoom_levels.json

@@ -52,4 +52,4 @@
         "micronsPerXPixel": 0.227,
         "micronsPerYPixel": 0.314
     }
-}
+}

dodal/devices/oav/oav_detector.py

@@ -1,3 +1,4 @@
+# type: ignore # OAV will soon be ophyd-async, see https://github.com/DiamondLightSource/dodal/issues/716
 from functools import partial
 
 from ophyd import ADComponent as ADC
@@ -46,6 +47,7 @@ class ZoomController(Device):
     sxst = Component(EpicsSignal, "MP:SELECT.SXST")
 
     def set_flatfield_on_zoom_level_one(self, value):
+        self.parent: OAV
         flat_applied = self.parent.proc.port_name.get()
         no_flat_applied = self.parent.cam.port_name.get()
         return self.parent.grid_snapshot.input_plugin.set(

dodal/devices/oav/oav_parameters.py

@@ -1,7 +1,8 @@
 import json
-import xml.etree.cElementTree as et
+import xml.etree.ElementTree as et
 from collections import ChainMap
-from typing import Any, Tuple
+from typing import Any
+from xml.etree.ElementTree import Element
 
 from dodal.devices.oav.oav_errors import (
     OAVError_BeamPositionNotFound,
@@ -20,6 +21,13 @@ OAV_CONFIG_JSON = (
 )
 
 
+def _get_element_as_float(node: Element, element_name: str) -> float:
+    element = node.find(element_name)
+    assert element is not None, f"{element_name} not found in {node}"
+    assert element.text
+    return float(element.text)
+
+
 class OAVParameters:
     """
     The parameters to set up the OAV depending on the context.
@@ -65,11 +73,11 @@ class OAVParameters:
             try:
                 param = param_type(param)
                 return param
-            except AssertionError:
+            except AssertionError as e:
                 raise TypeError(
                     f"OAV param {name} from the OAV centring params json file has the "
                     f"wrong type, should be {param_type} but is {type(param)}."
-                )
+                ) from e
 
         self.exposure: float = update("exposure", float)
         self.acquire_period: float = update("acqPeriod", float)
@@ -134,14 +142,14 @@ class OAVConfigParams:
         root = tree.getroot()
         levels = root.findall(".//zoomLevel")
         for node in levels:
-            if float(node.find("level").text) == zoom:
+            if _get_element_as_float(node, "level") == zoom:
                 self.micronsPerXPixel = (
-                    float(node.find("micronsPerXPixel").text)
+                    _get_element_as_float(node, "micronsPerXPixel")
                     * DEFAULT_OAV_WINDOW[0]
                     / xsize
                 )
                 self.micronsPerYPixel = (
-                    float(node.find("micronsPerYPixel").text)
+                    _get_element_as_float(node, "micronsPerYPixel")
                     * DEFAULT_OAV_WINDOW[1]
                     / ysize
                 )
@@ -155,7 +163,7 @@ class OAVConfigParams:
 
     def get_beam_position_from_zoom(
         self, zoom: float, xsize: int, ysize: int
-    ) -> Tuple[int, int]:
+    ) -> tuple[int, int]:
         """
         Extracts the beam location in pixels `xCentre` `yCentre`, for a requested zoom \
         level. The beam location is manually inputted by the beamline operator on GDA \
@@ -164,7 +172,7 @@ class OAVConfigParams:
         """
         crosshair_x_line = None
         crosshair_y_line = None
-        with open(self.display_config, "r") as f:
+        with open(self.display_config) as f:
             file_lines = f.readlines()
             for i in range(len(file_lines)):
                 if file_lines[i].startswith("zoomLevel = " + str(zoom)):
@@ -188,7 +196,7 @@ class OAVConfigParams:
 
     def calculate_beam_distance(
         self, horizontal_pixels: int, vertical_pixels: int
-    ) -> Tuple[int, int]:
+    ) -> tuple[int, int]:
         """
         Calculates the distance between the beam centre and the given (horizontal, vertical).
 

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -0,0 +1,100 @@
+import asyncio
+import io
+import pickle
+import uuid
+
+import numpy as np
+from aiohttp import ClientResponse, ClientSession
+from bluesky.protocols import Flyable
+from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core.signal import soft_signal_r_and_setter
+from ophyd_async.epics.signal import epics_signal_r
+from PIL import Image
+from redis.asyncio import StrictRedis
+
+from dodal.log import LOGGER
+
+
+async def get_next_jpeg(response: ClientResponse) -> bytes:
+    JPEG_START_BYTE = b"\xff\xd8"
+    JPEG_STOP_BYTE = b"\xff\xd9"
+    while True:
+        line = await response.content.readline()
+        if line.startswith(JPEG_START_BYTE):
+            return line + await response.content.readuntil(JPEG_STOP_BYTE)
+
+
+class OAVToRedisForwarder(StandardReadable, Flyable):
+    """Forwards OAV image data to redis. To use call:
+
+    > bps.kickoff(oav_forwarder)
+    > bps.monitor(oav_forwarder.uuid)
+    > bps.complete(oav_forwarder)
+
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        redis_host: str,
+        redis_password: str,
+        redis_db: int = 0,
+        name: str = "",
+        redis_key: str = "test-image",
+    ) -> None:
+        """Reads image data from the MJPEG stream on an OAV and forwards it into a
+        redis database. This is currently only used for murko integration.
+
+        Arguments:
+            prefix: str             the PV prefix of the OAV
+            redis_host: str         the host where the redis database is running
+            redis_password: str     the password for the redis database
+            redis_db: int           which redis database to connect to, defaults to 0
+            name: str               the name of this device
+            redis_key: str          the key to store data in, defaults to "test-image"
+        """
+        self.stream_url = epics_signal_r(str, f"{prefix}-DI-OAV-01:MJPG:HOST_RBV")
+
+        with self.add_children_as_readables():
+            self.uuid, self.uuid_setter = soft_signal_r_and_setter(str)
+
+        self.forwarding_task = None
+        self.redis_client = StrictRedis(
+            host=redis_host, password=redis_password, db=redis_db
+        )
+
+        self.redis_key = redis_key
+
+        # The uuid that images are being saved under, this should be monitored for
+        # callbacks to correlate the data
+        self.uuid, self.uuid_setter = soft_signal_r_and_setter(str)
+
+        super().__init__(name=name)
+
+    async def _get_frame_and_put_to_redis(self, response: ClientResponse):
+        """Converts the data that comes in as a jpeg byte stream into a numpy array of
+        RGB values, pickles this array then writes it to redis.
+        """
+        jpeg_bytes = await get_next_jpeg(response)
+        self.uuid_setter(image_uuid := str(uuid.uuid4()))
+        img = Image.open(io.BytesIO(jpeg_bytes))
+        image_data = pickle.dumps(np.asarray(img))
+        await self.redis_client.hset(self.redis_key, image_uuid, image_data)  # type: ignore
+        LOGGER.debug(f"Sent frame to redis key {self.redis_key} with uuid {image_uuid}")
+
+    async def _stream_to_redis(self):
+        stream_url = await self.stream_url.get_value()
+        async with ClientSession() as session:
+            async with session.get(stream_url) as response:
+                while True:
+                    await self._get_frame_and_put_to_redis(response)
+                    await asyncio.sleep(0.01)
+
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        self.forwarding_task = asyncio.create_task(self._stream_to_redis())
+
+    @AsyncStatus.wrap
+    async def complete(self):
+        assert self.forwarding_task, "Device not kicked off"
+        self.forwarding_task.cancel()

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -5,6 +5,7 @@ import numpy as np
 from numpy.typing import NDArray
 from ophyd_async.core import (
     AsyncStatus,
+    HintedSignal,
     StandardReadable,
     observe_value,
     soft_signal_r_and_setter,
@@ -50,11 +51,13 @@ class PinTipDetection(StandardReadable):
         self._prefix: str = prefix
         self._name = name
 
-        self.triggered_tip, _ = soft_signal_r_and_setter(Tip, name="triggered_tip")
-        self.triggered_top_edge, _ = soft_signal_r_and_setter(
+        self.triggered_tip, self._tip_setter = soft_signal_r_and_setter(
+            Tip, name="triggered_tip"
+        )
+        self.triggered_top_edge, self._top_edge_setter = soft_signal_r_and_setter(
             NDArray[np.uint32], name="triggered_top_edge"
         )
-        self.triggered_bottom_edge, _ = soft_signal_r_and_setter(
+        self.triggered_bottom_edge, self._bottom_edge_setter = soft_signal_r_and_setter(
             NDArray[np.uint32], name="triggered_bottom_edge"
         )
         self.array_data = epics_signal_r(NDArray[np.uint8], f"pva://{prefix}PVA:ARRAY")
@@ -75,24 +78,25 @@ class PinTipDetection(StandardReadable):
         self.min_tip_height = soft_signal_rw(int, 5, name="min_tip_height")
         self.validity_timeout = soft_signal_rw(float, 5.0, name="validity_timeout")
 
-        self.set_readable_signals(
-            read=[
+        self.add_readables(
+            [
                 self.triggered_tip,
                 self.triggered_top_edge,
                 self.triggered_bottom_edge,
             ],
+            wrapper=HintedSignal,
         )
 
         super().__init__(name=name)
 
-    async def _set_triggered_values(self, results: SampleLocation):
+    def _set_triggered_values(self, results: SampleLocation):
         tip = (results.tip_x, results.tip_y)
         if tip == self.INVALID_POSITION:
             raise InvalidPinException
         else:
-            await self.triggered_tip._backend.put(tip)
-        await self.triggered_top_edge._backend.put(results.edge_top)
-        await self.triggered_bottom_edge._backend.put(results.edge_bottom)
+            self._tip_setter(tip)
+        self._top_edge_setter(results.edge_top)
+        self._bottom_edge_setter(results.edge_bottom)
 
     async def _get_tip_and_edge_data(
         self, array_data: NDArray[np.uint8]
@@ -132,9 +136,7 @@ class PinTipDetection(StandardReadable):
         location = sample_detection.processArray(array_data)
         end_time = time.time()
         LOGGER.debug(
-            "Sample location detection took {}ms".format(
-                (end_time - start_time) * 1000.0
-            )
+            f"Sample location detection took {(end_time - start_time) * 1000.0}ms"
         )
         return location
 
@@ -150,9 +152,9 @@ class PinTipDetection(StandardReadable):
             async for value in observe_value(self.array_data):
                 try:
                     location = await self._get_tip_and_edge_data(value)
-                    await self._set_triggered_values(location)
+                    self._set_triggered_values(location)
                 except Exception as e:
-                    LOGGER.warn(
+                    LOGGER.warning(
                         f"Failed to detect pin-tip location, will retry with next image: {e}"
                     )
                 else:
@@ -166,6 +168,6 @@ class PinTipDetection(StandardReadable):
             LOGGER.error(
                 f"No tip found in {await self.validity_timeout.get_value()} seconds."
             )
-            await self.triggered_tip._backend.put(self.INVALID_POSITION)
-            await self.triggered_bottom_edge._backend.put(np.array([]))
-            await self.triggered_top_edge._backend.put(np.array([]))
+            self._tip_setter(self.INVALID_POSITION)
+            self._bottom_edge_setter(np.array([]))
+            self._top_edge_setter(np.array([]))

dodal/devices/oav/pin_image_recognition/utils.py

@@ -1,6 +1,7 @@
+from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
-from typing import Callable, Final, Tuple
+from typing import Final
 
 import cv2
 import numpy as np
@@ -103,7 +104,7 @@ class SampleLocation:
     edge_bottom: np.ndarray
 
 
-class MxSampleDetect(object):
+class MxSampleDetect:
     def __init__(
         self,
         *,
@@ -161,7 +162,7 @@ class MxSampleDetect(object):
     @staticmethod
     def _first_and_last_nonzero_by_columns(
         arr: np.ndarray,
-    ) -> Tuple[np.ndarray, np.ndarray]:
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
         Finds the indexes of the first & last non-zero values by column in a 2d array.
 
@@ -243,9 +244,7 @@ class MxSampleDetect(object):
             bottom[x + 1 :] = NONE_VALUE
 
         LOGGER.info(
-            "pin-tip detection: Successfully located pin tip at (x={}, y={})".format(
-                tip_x, tip_y
-            )
+            f"pin-tip detection: Successfully located pin tip at (x={tip_x}, y={tip_y})"
         )
         return SampleLocation(
             tip_x=tip_x, tip_y=tip_y, edge_bottom=bottom, edge_top=top