dls-dodal 1.42.0__py3-none-any.whl → 1.44.0__py3-none-any.whl

dodal/devices/i13_1/merlin.py

@@ -3,7 +3,6 @@ from ophyd_async.epics import adcore
 
 from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
 from dodal.devices.i13_1.merlin_controller import MerlinController
-from dodal.devices.i13_1.merlin_io import MerlinDriverIO
 
 
 class Merlin(StandardDetector):
@@ -18,7 +17,7 @@ class Merlin(StandardDetector):
         fileio_suffix=HDF5_SUFFIX,
         name: str = "",
     ):
-        self.drv = MerlinDriverIO(prefix + drv_suffix)
+        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
         self.hdf = adcore.NDFileHDFIO(prefix + fileio_suffix)
 
         super().__init__(

dodal/devices/i13_1/merlin_controller.py

@@ -6,17 +6,21 @@ from ophyd_async.core import (
     AsyncStatus,
     TriggerInfo,
 )
-from ophyd_async.epics import adcore
-from ophyd_async.epics.adcore import ADBaseController
-
-from dodal.devices.i13_1.merlin_io import MerlinDriverIO, MerlinImageMode
+from ophyd_async.epics.adcore import (
+    DEFAULT_GOOD_STATES,
+    ADBaseController,
+    ADBaseIO,
+    ADImageMode,
+    ADState,
+    stop_busy_record,
+)
 
 
 class MerlinController(ADBaseController):
     def __init__(
         self,
-        driver: MerlinDriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        driver: ADBaseIO,
+        good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
     ) -> None:
         self.driver = driver
         self.good_states = good_states
@@ -34,7 +38,7 @@ class MerlinController(ADBaseController):
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_triggers),
-            self.driver.image_mode.set(MerlinImageMode.MULTIPLE),
+            self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 
     async def wait_for_idle(self):
@@ -44,4 +48,4 @@ class MerlinController(ADBaseController):
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await adcore.stop_busy_record(self.driver.acquire, False, timeout=1)
+        await stop_busy_record(self.driver.acquire, False, timeout=1)

dodal/devices/i19/beamstop.py

@@ -0,0 +1,30 @@
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw, epics_signal_x
+from ophyd_async.epics.motor import Motor
+
+
+class HomeGroup(StrictEnum):
+    NONE = "none"
+    ALL = "All"
+    X = "X"
+    Y = "Y"
+    Z = "Z"
+
+
+class HomingControl(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.homing_group = epics_signal_rw(HomeGroup, f"{prefix}:HMGRP")
+        self.home = epics_signal_x(f"{prefix}:HOME")
+        super().__init__(name)
+
+
+class BeamStop(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(f"{prefix}X")
+            self.y = Motor(f"{prefix}Y")
+            self.z = Motor(f"{prefix}Z")
+
+        self.homing = HomingControl(f"{prefix}HM", name)
+
+        super().__init__(name)

dodal/devices/i19/hutch_access.py

@@ -1,6 +1,8 @@
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r
 
+ACCESS_DEVICE_NAME = "access_control"  # Device name in i19-blueapi
+
 
 class HutchAccessControl(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:

dodal/devices/i19/shutter.py

@@ -1,57 +1,79 @@
 from enum import Enum
 
+from aiohttp import ClientSession
 from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core import AsyncStatus, StandardReadable, StandardReadableFormat
 from ophyd_async.epics.core import epics_signal_r
 
-from dodal.devices.hutch_shutter import HutchShutter, ShutterDemand
+from dodal.devices.hutch_shutter import ShutterDemand, ShutterState
+from dodal.devices.i19.hutch_access import ACCESS_DEVICE_NAME
 from dodal.log import LOGGER
 
-
-class HutchInvalidError(Exception):
-    pass
+OPTICS_BLUEAPI_URL = "https://i19-blueapi.diamond.ac.uk"
 
 
 class HutchState(str, Enum):
     EH1 = "EH1"
     EH2 = "EH2"
-    INVALID = "INVALID"
 
 
-class HutchConditionalShutter(StandardReadable, Movable):
+class AccessControlledShutter(StandardReadable, Movable[ShutterDemand]):
     """ I19-specific device to operate the hutch shutter.
 
-    This device evaluates the hutch state value to work out which of the two I19 \
-    hutches is in use and then implements the HutchShutter device to operate the \
-    experimental shutter.
+    This device will send a REST call to the blueapi instance controlling the optics \
+    hutch running on the I19 cluster, which will evaluate the current hutch in use vs \
+    the hutch sending the request and decide if the plan will be run or not.
     As the two hutches are located in series, checking the hutch in use is necessary to \
     avoid accidentally operating the shutter from one hutch while the other has beamtime.
 
-    The hutch name should be passed to the device upon instantiation. If this does not \
-    coincide with the current hutch in use, a warning will be logged and the shutter \
-    will not be operated. This is to allow for testing of plans.
-    An error will instead be raised if the hutch state reads as "INVALID".
+    The name of the hutch that wants to operate the shutter should be passed to the \
+    device upon instantiation.
+
+    For details see the architecture described in \
+    https://github.com/DiamondLightSource/i19-bluesky/issues/30.
     """
 
     def __init__(self, prefix: str, hutch: HutchState, name: str = "") -> None:
-        self.shutter = HutchShutter(prefix=prefix, name=name)
-        bl_prefix = prefix.split("-")[0]
-        self.hutch_state = epics_signal_r(str, f"{bl_prefix}-OP-STAT-01:EHStatus.VALA")
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.shutter_status = epics_signal_r(ShutterState, f"{prefix}STA")
         self.hutch_request = hutch
+        self.url = OPTICS_BLUEAPI_URL
         super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
-        hutch_in_use = await self.hutch_state.get_value()
-        LOGGER.info(f"Current hutch in use: {hutch_in_use}")
-        if hutch_in_use == HutchState.INVALID:
-            raise HutchInvalidError(
-                "The hutch state is invalid. Contact the beamline staff."
-            )
-        if hutch_in_use != self.hutch_request:
-            # NOTE Warn but don't fail
-            LOGGER.warning(
-                f"{self.hutch_request} is not the hutch in use. Shutter will not be operated."
-            )
-        else:
-            await self.shutter.set(value)
+        REQUEST_PARAMS = {
+            "name": "operate_shutter_plan",
+            "params": {
+                "experiment_hutch": self.hutch_request.value,
+                "access_device": ACCESS_DEVICE_NAME,
+                "shutter_demand": value,
+            },
+        }
+        async with ClientSession(base_url=self.url, raise_for_status=True) as session:
+            # First submit the plan to the worker
+            async with session.post("/tasks", data=REQUEST_PARAMS) as response:
+                LOGGER.debug(
+                    f"Task submitted to the worker, response status: {response.status}"
+                )
+
+                try:
+                    data = await response.json()
+                    task_id = data["task_id"]
+                except Exception as e:
+                    LOGGER.error(
+                        f"Failed to get task_id from {self.url}/tasks POST. ({e})"
+                    )
+                    raise
+            # Then set the task as active and run asap
+            async with session.put(
+                "/worker/tasks", data={"task_id": task_id}
+            ) as response:
+                if not response.ok:
+                    LOGGER.error(
+                        f"""Unable to operate the shutter.
+                        Session PUT responded with {response.status}: {response.reason}.
+                        """
+                    )
+                    return
+                LOGGER.debug(f"Run operate shutter plan, task_id: {task_id}")

dodal/devices/i22/nxsas.py

@@ -6,7 +6,7 @@ from typing import TypeVar
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import PathProvider
-from ophyd_async.epics.adaravis import AravisController, AravisDetector
+from ophyd_async.epics.adaravis import AravisDetector
 from ophyd_async.epics.adpilatus import PilatusDetector
 
 ValueAndUnits = tuple[float, str]
@@ -149,7 +149,6 @@ class NXSasOAV(AravisDetector):
         fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
-        gpio_number: AravisController.GPIO_NUMBER = 1,
     ):
         """Extends detector with configuration metadata required or desired
         to comply with the NXsas application definition.
@@ -162,7 +161,6 @@ class NXSasOAV(AravisDetector):
             drv_suffix=drv_suffix,
             fileio_suffix=fileio_suffix,
             name=name,
-            gpio_number=gpio_number,
         )
         self._metadata_holder = metadata_holder
 

dodal/devices/i24/focus_mirrors.py

@@ -1,7 +1,7 @@
 from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class HFocusMode(StrictEnum):
@@ -40,10 +40,10 @@ class FocusMirrorsMode(StandardReadable):
         self.vertical = epics_signal_rw(VFocusMode, prefix + "G0:TARGETAPPLY")
 
         with self.add_children_as_readables():
-            self.beam_size_x = create_hardware_backed_soft_signal(
+            self.beam_size_x = create_r_hardware_backed_soft_signal(
                 int, self._get_beam_size_x, units="um"
             )
-            self.beam_size_y = create_hardware_backed_soft_signal(
+            self.beam_size_y = create_r_hardware_backed_soft_signal(
                 int, self._get_beam_size_y, units="um"
             )
 

dodal/devices/i24/pilatus_metadata.py

@@ -5,7 +5,7 @@ import re
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class PilatusMetadata(StandardReadable):
@@ -14,7 +14,7 @@ class PilatusMetadata(StandardReadable):
         self.template = epics_signal_r(str, prefix + "cam1:FileTemplate_RBV")
         self.filenumber = epics_signal_r(int, prefix + "cam1:FileNumber_RBV")
         with self.add_children_as_readables():
-            self.filename_template = create_hardware_backed_soft_signal(
+            self.filename_template = create_r_hardware_backed_soft_signal(
                 str, self._get_full_filename_template
             )
         super().__init__(name)

dodal/devices/i24/pmac.py

@@ -71,7 +71,7 @@ class PMACStringMove(Triggerable):
         await self.signal_ref().set(self.cmd_string, wait=True)
 
 
-class PMACStringLaser(Device, Movable):
+class PMACStringLaser(Device, Movable[LaserSettings]):
     """Set the pmac_string to control the laser."""
 
     def __init__(
@@ -90,7 +90,7 @@ class PMACStringLaser(Device, Movable):
         await self._signal_ref().set(value.value)
 
 
-class PMACStringEncReset(Device, Movable):
+class PMACStringEncReset(Device, Movable[EncReset]):
     """Set a pmac_string to control the encoder channels in the controller."""
 
     def __init__(

dodal/devices/oav/oav_detector.py

@@ -9,10 +9,10 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.devices.areadetector.plugins.CAM import Cam
 from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
-from dodal.devices.oav.snapshots.snapshot_with_beam_centre import SnapshotWithBeamCentre
+from dodal.devices.oav.snapshots.snapshot import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
 
 
@@ -29,7 +29,7 @@ def _get_correct_zoom_string(zoom: str) -> str:
     return zoom
 
 
-class ZoomController(StandardReadable, Movable):
+class ZoomController(StandardReadable, Movable[str]):
     """
     Device to control the zoom level. This should be set like
         o = OAV(name="oav")
@@ -63,24 +63,22 @@ class OAV(StandardReadable):
 
         with self.add_children_as_readables():
             self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
-            self.microns_per_pixel_x = create_hardware_backed_soft_signal(
+            self.microns_per_pixel_x = create_r_hardware_backed_soft_signal(
                 float,
                 lambda: self._get_microns_per_pixel(Coords.X),
             )
-            self.microns_per_pixel_y = create_hardware_backed_soft_signal(
+            self.microns_per_pixel_y = create_r_hardware_backed_soft_signal(
                 float,
                 lambda: self._get_microns_per_pixel(Coords.Y),
             )
-            self.beam_centre_i = create_hardware_backed_soft_signal(
+            self.beam_centre_i = create_r_hardware_backed_soft_signal(
                 int, lambda: self._get_beam_position(Coords.X)
             )
-            self.beam_centre_j = create_hardware_backed_soft_signal(
+            self.beam_centre_j = create_r_hardware_backed_soft_signal(
                 int, lambda: self._get_beam_position(Coords.Y)
             )
-            self.snapshot = SnapshotWithBeamCentre(
+            self.snapshot = Snapshot(
                 f"{self._prefix}MJPG:",
-                self.beam_centre_i,
-                self.beam_centre_j,
                 self._name,
             )
 

dodal/devices/oav/snapshots/snapshot.py

@@ -0,0 +1,21 @@
+from PIL import Image
+
+from dodal.devices.areadetector.plugins.MJPG import MJPG
+
+CROSSHAIR_LENGTH_PX = 20
+CROSSHAIR_OUTLINE_COLOUR = "Black"
+CROSSHAIR_FILL_COLOUR = "White"
+
+
+class Snapshot(MJPG):
+    """A child of MJPG which, when triggered, saves the image to disk."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ) -> None:
+        super().__init__(prefix, name)
+
+    async def post_processing(self, image: Image.Image):
+        await self._save_image(image)

dodal/devices/oav/snapshots/snapshot_image_processing.py

@@ -0,0 +1,74 @@
+from PIL import Image, ImageDraw
+
+from dodal.devices.oav.utils import Pixel
+
+CROSSHAIR_LENGTH_PX = 20
+CROSSHAIR_OUTLINE_COLOUR = "Black"
+CROSSHAIR_FILL_COLOUR = "White"
+
+
+def draw_crosshair(image: Image.Image, beam_x: int, beam_y: int):
+    """
+    Draw a crosshair at the beam centre coordinates specified.
+    Args:
+        image: The image to draw the crosshair onto. This is mutated.
+        beam_x: The x-coordinate of the crosshair (pixels)
+        beam_y: The y-coordinate of the crosshair (pixels)
+    """
+    draw = ImageDraw.Draw(image)
+    OUTLINE_WIDTH = 1
+    HALF_LEN = CROSSHAIR_LENGTH_PX / 2
+    draw.rectangle(
+        [
+            beam_x - OUTLINE_WIDTH,
+            beam_y - HALF_LEN - OUTLINE_WIDTH,
+            beam_x + OUTLINE_WIDTH,
+            beam_y + HALF_LEN + OUTLINE_WIDTH,
+        ],
+        fill=CROSSHAIR_OUTLINE_COLOUR,
+    )
+    draw.rectangle(
+        [
+            beam_x - HALF_LEN - OUTLINE_WIDTH,
+            beam_y - OUTLINE_WIDTH,
+            beam_x + HALF_LEN + OUTLINE_WIDTH,
+            beam_y + OUTLINE_WIDTH,
+        ],
+        fill=CROSSHAIR_OUTLINE_COLOUR,
+    )
+    draw.line(
+        ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
+        fill=CROSSHAIR_FILL_COLOUR,
+    )
+    draw.line(
+        ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
+        fill=CROSSHAIR_FILL_COLOUR,
+    )
+
+
+def compute_beam_centre_pixel_xy_for_mm_position(
+    sample_pos_mm: tuple[float, float],
+    beam_pos_at_origin_px: Pixel,
+    microns_per_pixel: tuple[float, float],
+) -> Pixel:
+    """
+    Compute the location of the beam centre in pixels on a reference image.
+    Args:
+        sample_pos_mm: x, y location of the sample in mm relative to when the reference image
+            was taken.
+        beam_pos_at_origin_px: x, y position of the beam centre in the reference image (pixels)
+        microns_per_pixel: x, y scaling factor relating the sample position to the position in the image.
+    Returns:
+        x, y location of the beam centre (pixels)
+
+    """
+
+    def centre(sample_pos, beam_pos, um_per_px) -> int:
+        return beam_pos + sample_pos * 1000 / um_per_px
+
+    return Pixel(
+        centre(sp, bp, mpp)
+        for sp, bp, mpp in zip(
+            sample_pos_mm, beam_pos_at_origin_px, microns_per_pixel, strict=True
+        )
+    )

dodal/devices/pressure_jump_cell.py

@@ -76,7 +76,7 @@ class AllValvesControlState:
     valve_6: FastValveControlRequest | None = None
 
 
-class AllValvesControl(StandardReadable, Movable):
+class AllValvesControl(StandardReadable, Movable[AllValvesControlState]):
     """
     valves 2, 4, 7, 8 are not controlled by the IOC,
     as they are under manual control.
@@ -151,7 +151,9 @@ class AllValvesControl(StandardReadable, Movable):
         )
 
 
-class ValveControl(StandardReadable, Movable):
+class ValveControl(
+    StandardReadable, Movable[ValveControlRequest | ValveOpenSeqRequest]
+):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.close = epics_signal_rw(ValveControlRequest, prefix + ":CON")
@@ -170,7 +172,9 @@ class ValveControl(StandardReadable, Movable):
         return set_status
 
 
-class FastValveControl(StandardReadable, Movable):
+class FastValveControl(
+    StandardReadable, Movable[FastValveControlRequest | ValveOpenSeqRequest]
+):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.close = epics_signal_rw(FastValveControlRequest, prefix + ":CON")

dodal/devices/robot.py

@@ -52,7 +52,7 @@ class ErrorStatus(Device):
             raise RobotLoadFailed(int(error_code), error_string) from raise_from
 
 
-class BartRobot(StandardReadable, Movable):
+class BartRobot(StandardReadable, Movable[SampleLocation]):
     """The sample changing robot."""
 
     # How long to wait for the robot if it is busy soaking/drying

dodal/devices/thawer.py

@@ -1,6 +1,6 @@
 from asyncio import Task, create_task, sleep
 
-from bluesky.protocols import Stoppable
+from bluesky.protocols import Movable, Stoppable
 from ophyd_async.core import (
     AsyncStatus,
     Device,
@@ -21,18 +21,18 @@ class ThawerStates(StrictEnum):
     ON = "On"
 
 
-class ThawingTimer(Device, Stoppable):
+class ThawingTimer(Device, Stoppable, Movable[float]):
     def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
         self._control_signal_ref = Reference(control_signal)
         self._thawing_task: Task | None = None
         super().__init__("thaw_for_time_s")
 
     @AsyncStatus.wrap
-    async def set(self, time_to_thaw_for: float):
+    async def set(self, value: float):
         await self._control_signal_ref().set(ThawerStates.ON)
         if self._thawing_task and not self._thawing_task.done():
             raise ThawingException("Thawing task already in progress")
-        self._thawing_task = create_task(sleep(time_to_thaw_for))
+        self._thawing_task = create_task(sleep(value))
         try:
             await self._thawing_task
         finally:

dodal/devices/undulator.py

@@ -46,7 +46,7 @@ def _get_closest_gap_for_energy(
     return table[1][idx]
 
 
-class Undulator(StandardReadable, Movable):
+class Undulator(StandardReadable, Movable[float]):
     """
     An Undulator-type insertion device, used to control photon emission at a given
     beam energy.

dodal/devices/undulator_dcm.py

@@ -12,7 +12,7 @@ from .undulator import Undulator
 ENERGY_TIMEOUT_S: float = 30.0
 
 
-class UndulatorDCM(StandardReadable, Movable):
+class UndulatorDCM(StandardReadable, Movable[float]):
     """
     Composite device to handle changing beamline energies, wraps the Undulator and the
     DCM. The DCM has a motor which controls the beam energy, when it moves, the

dodal/devices/util/epics_util.py

@@ -114,7 +114,7 @@ def call_func(func: Callable[[], StatusBase]) -> StatusBase:
     return func()
 
 
-class SetWhenEnabled(OphydAsyncDevice, Movable):
+class SetWhenEnabled(OphydAsyncDevice, Movable[int]):
     """A device that sets the proc field of a PV when it becomes enabled."""
 
     def __init__(self, name: str = "", prefix: str = ""):

dodal/devices/zebra/zebra.py

@@ -4,6 +4,7 @@ import asyncio
 from enum import Enum
 from functools import partialmethod
 
+from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     DeviceVector,
@@ -74,7 +75,7 @@ class SoftInState(StrictEnum):
     NO = "No"
 
 
-class ArmingDevice(StandardReadable):
+class ArmingDevice(StandardReadable, Movable[ArmDemand]):
     """A useful device that can abstract some of the logic of arming.
     Allows a user to just call arm.set(ArmDemand.ARM)"""
 
@@ -94,8 +95,8 @@ class ArmingDevice(StandardReadable):
                 return
 
     @AsyncStatus.wrap
-    async def set(self, demand: ArmDemand):
-        await asyncio.wait_for(self._set_armed(demand), timeout=self.TIMEOUT)
+    async def set(self, value: ArmDemand):
+        await asyncio.wait_for(self._set_armed(value), timeout=self.TIMEOUT)
 
 
 class PositionCompare(StandardReadable):

dodal/devices/zebra/zebra_controlled_shutter.py

@@ -19,7 +19,7 @@ class ZebraShutterControl(StrictEnum):
     AUTO = "Auto"
 
 
-class ZebraShutter(StandardReadable, Movable):
+class ZebraShutter(StandardReadable, Movable[ZebraShutterState]):
     """The shutter on most MX beamlines is controlled by the zebra.
 
     Internally in the zebra there are two AND gates, one for manual control and one for

dodal/plan_stubs/data_session.py

@@ -1,6 +1,9 @@
+import logging
+
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import MsgGenerator, make_decorator
+from ophyd_async.core import PathProvider
 
 from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.common.types import UpdatingPathProvider
@@ -10,7 +13,7 @@ DATA_GROUPS = "data_groups"
 
 
 def attach_data_session_metadata_wrapper(
-    plan: MsgGenerator, provider: UpdatingPathProvider | None = None
+    plan: MsgGenerator, provider: PathProvider | None = None
 ) -> MsgGenerator:
     """
     Attach data session metadata to the runs within a plan and make it correlate
@@ -30,14 +33,19 @@ def attach_data_session_metadata_wrapper(
     Yields:
         Iterator[Msg]: Plan messages
     """
-    if provider is None:
-        provider = get_path_provider()
-    yield from bps.wait_for([provider.update])
-    ress = yield from bps.wait_for([provider.data_session])
-    data_session = ress[0].result()
-    # https://github.com/DiamondLightSource/dodal/issues/452
-    # As part of 452, write each dataCollection into their own folder, then can use resource_dir directly
-    yield from bpp.inject_md_wrapper(plan, md={DATA_SESSION: data_session})
+    provider = provider or get_path_provider()
+    if isinstance(provider, UpdatingPathProvider):
+        yield from bps.wait_for([provider.update])
+        ress = yield from bps.wait_for([provider.data_session])
+        data_session = ress[0].result()
+        # https://github.com/DiamondLightSource/dodal/issues/452
+        # As part of 452, write each dataCollection into their own folder, then can use resource_dir directly
+        yield from bpp.inject_md_wrapper(plan, md={DATA_SESSION: data_session})
+    else:
+        logging.warning(
+            f"{provider} is not an UpdatingPathProvider, {attach_data_session_metadata_wrapper.__name__} will have no effect"
+        )
+        yield from plan
 
 
 attach_data_session_metadata_decorator = make_decorator(