dls-dodal 1.32.0__tar.gz → 1.33.0__tar.gz

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.32.0
+Version: 1.33.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/docs/reference/device-standards.rst

@@ -21,6 +21,17 @@ should think about where to place them in the following order:
 
 This is in an effort to avoid duplication across facilities/beamlines. 
 
+Device Best Practices
+----------------------------
+
+Ophyd-async directory contains a flowchart_ for a simplified decision tree about what interfaces
+should a given device implement. In addition to this the following guidelines are strongly recommended:
+
+#. Devices should contain only the PV suffixes that are generic for any instance of the device. See `PV Suffixes`_
+#. Anything in a device that is expected to be set externally should be a signal. See `Use of signals`_
+#. Devices should not hold state, when they are read they should read the hardware. See `Holding State`_
+
+
 PV Suffixes
 -----------
 
@@ -86,16 +97,78 @@ Instead you should make a soft signal:
     
     class MyDevice(Device):
         def __init__(self):
-             self.param = create_soft_signal(str, "", self.name)
+             self.param = soft_signal_rw(str)
     
     my_device = MyDevice()
     def my_plan():
         yield from bps.mv(my_device.param, "new_value")
 
-Ophyd Devices best practices
-----------------------------
 
-Ophyd-async directory contains a flowchart_ for a simplified decision tree about what interfaces
-should a given device implement.
+Holding State
+-------------
+
+Devices should avoid holding state as much as possible. Ophyd devices are mostly trying to reflect the state of hardware and so when the device is read that hardware should be read.
+
+If the device holds the state itself it is likely to not reflect the real hardware if:
+* The device has just been initialised
+* The hardware has changed independently e.g. via EPICS directly
+* The hardware has failed to do what the device expected
+
+For example, if I have a device that I would like to treat as moving in/out based on an underlying axis then it would be incorrect to implement it like this:
+
+.. code-block:: python
+
+    class InOut(Enum):
+        IN = 0
+        OUT = 0
+
+    class MyDevice(Device):
+        def __init__(self):
+            self.underlying_motor = Motor("MOTOR")
+            with self.add_children_as_readables():
+                self.in_out, self._in_out_setter = soft_signal_r_and_setter(InOut)
+                
+
+        @AsyncStatus.wrap
+        async def set(self, value: InOut):
+            if value == InOut.IN:
+                await self.underlying_motor.set(100)
+            else:
+                await self.underlying_motor.set(0)
+            self._in_out_setter(value)
+
+While this may appear to work fine during normal operation the state of in_out is only ever updated if the ophyd device is set. It is incorrect to assume that underlying_motor only changes
+based on this and so this has the issues listed above. Instead you should make sure to update in_out whenever the device is read e.g.
+
+.. code-block:: python
+
+    class InOut(Enum):
+        IN = 0
+        OUT = 0
+
+    class MyDevice(Device):
+        def __init__(self):
+            self.underlying_motor = Motor("MOTOR")
+            with self.add_children_as_readables():
+                self.in_out = create_hardware_backed_soft_signal(InOut, self._get_in_out_from_hardware)
+                
+        async def _get_in_out_from_hardware(self):
+            current_position = await self.underlying_motor.get_value()
+            if isclose(current_position, 0):
+                return InOut.IN
+            elif isclose(current_position, 100):
+                return InOut.OUT
+            else:
+                raise ValueError()
+
+
+        @AsyncStatus.wrap
+        async def set(self, value: InOut):
+            if value == InOut.IN:
+                await self.underlying_motor.set(100)
+            else:
+                await self.underlying_motor.set(0)
+
+This will be simplified by https://github.com/bluesky/ophyd-async/issues/525
 
 .. _flowchart: https://blueskyproject.io/ophyd-async/main/how-to/choose-interfaces-for-devices.html

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/pull_request_template.md

@@ -6,6 +6,6 @@ Fixes #ISSUE
 
 ### Checks for reviewer
 - [ ] Would the PR title make sense to a scientist on a set of release notes
-- [ ] If a new device has been added does it follow the [standards](https://github.com/DiamondLightSource/dodal/wiki/Device-Standards)
+- [ ] If a new device has been added does it follow the [standards](https://diamondlightsource.github.io/dodal/main/reference/device-standards.html)
 - [ ] If changing the API for a pre-existing device, ensure that any beamlines using this device have updated their Bluesky plans accordingly
 - [ ] Have the connection tests for the relevant beamline(s) been run via `dodal connect ${BEAMLINE}`

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/src/dls_dodal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.32.0
+Version: 1.33.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/src/dls_dodal.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ src/dodal/beamline_specific_utils/__init__.py
 src/dodal/beamline_specific_utils/i03.py
 src/dodal/beamlines/README.md
 src/dodal/beamlines/__init__.py
+src/dodal/beamlines/b01_1.py
 src/dodal/beamlines/i03.py
 src/dodal/beamlines/i04.py
 src/dodal/beamlines/i04_1.py
@@ -97,6 +98,7 @@ src/dodal/beamlines/training_rig.py
 src/dodal/common/__init__.py
 src/dodal/common/coordination.py
 src/dodal/common/maths.py
+src/dodal/common/signal_utils.py
 src/dodal/common/types.py
 src/dodal/common/udc_directory_provider.py
 src/dodal/common/visit.py

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/src/dodal/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.32.0'
-__version_tuple__ = version_tuple = (1, 32, 0)
+__version__ = version = '1.33.0'
+__version_tuple__ = version_tuple = (1, 33, 0)

dls_dodal-1.33.0/src/dodal/beamlines/b01_1.py

@@ -0,0 +1,77 @@
+from pathlib import Path
+
+from ophyd_async.epics.adaravis import AravisDetector
+from ophyd_async.fastcs.panda import HDFPanda
+
+from dodal.common.beamlines.beamline_utils import (
+    device_instantiation,
+    get_path_provider,
+    set_path_provider,
+)
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
+from dodal.devices.synchrotron import Synchrotron
+from dodal.log import set_beamline as set_log_beamline
+
+BL = "c01"
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/dls/b01-1/data/"),
+        client=LocalDirectoryServiceClient(),
+    )
+)
+
+"""
+NOTE: Due to ArgoCD and the k8s cluster configuration those PVs are not available remotely.
+You need to be on the beamline-local network to access them.
+The simplest way to do this is to `ssh b01-1-ws001` and run `dodal connect b01_1` from there.
+remember about the underscore in the beamline name.
+
+See the IOC status here:
+https://argocd.diamond.ac.uk/applications?showFavorites=false&proj=&sync=&autoSync=&health=&namespace=&cluster=&labels=
+"""
+
+
+def panda(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> HDFPanda:
+    return device_instantiation(
+        device_factory=HDFPanda,
+        name="panda",
+        prefix="-EA-PANDA-01:",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+        path_provider=get_path_provider(),
+    )
+
+
+def synchrotron(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> Synchrotron:
+    return device_instantiation(
+        Synchrotron,
+        "synchrotron",
+        "",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+        bl_prefix=False,
+    )
+
+
+def manta(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> AravisDetector:
+    return device_instantiation(
+        AravisDetector,
+        "manta",
+        "-DI-DCAM-02:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+        path_provider=get_path_provider(),
+        drv_suffix="CAM:",
+        hdf_suffix="HDF5:",
+    )

dls_dodal-1.33.0/src/dodal/common/signal_utils.py

@@ -0,0 +1,53 @@
+from collections.abc import Callable, Coroutine
+from typing import Any, TypeVar
+
+from bluesky.protocols import Reading
+from ophyd_async.core import SignalR, SoftSignalBackend
+from ophyd_async.core._soft_signal_backend import SignalMetadata
+
+T = TypeVar("T")
+
+
+class HarwareBackedSoftSignalBackend(SoftSignalBackend[T]):
+    def __init__(
+        self,
+        get_from_hardware_func: Callable[[], Coroutine[Any, Any, T]],
+        *args,
+        **kwargs,
+    ) -> None:
+        self.get_from_hardware_func = get_from_hardware_func
+        super().__init__(*args, **kwargs)
+
+    async def _update_value(self):
+        new_value = await self.get_from_hardware_func()
+        await self.put(new_value)
+
+    async def get_reading(self) -> Reading:
+        await self._update_value()
+        return await super().get_reading()
+
+    async def get_value(self) -> T:
+        await self._update_value()
+        return await super().get_value()
+
+
+def create_hardware_backed_soft_signal(
+    datatype: type[T],
+    get_from_hardware_func: Callable[[], Coroutine[Any, Any, T]],
+    units: str | None = None,
+    precision: int | None = None,
+):
+    """Creates a soft signal that, when read will call the function passed into
+    `get_from_hardware_func` and return this.
+
+    This will allow you to make soft signals derived from arbitrary hardware signals.
+    However, calling subscribe on this signal does not give you a sensible value and
+    the signal is currently read only. See https://github.com/bluesky/ophyd-async/issues/525
+    for a more full solution.
+    """
+    metadata = SignalMetadata(units=units, precision=precision)
+    return SignalR(
+        backend=HarwareBackedSoftSignalBackend(
+            get_from_hardware_func, datatype, metadata=metadata
+        )
+    )

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/src/dodal/devices/aperturescatterguard.py

@@ -8,11 +8,11 @@ from ophyd_async.core import (
     AsyncStatus,
     HintedSignal,
     StandardReadable,
-    soft_signal_rw,
 )
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
 from dodal.devices.aperture import Aperture
 from dodal.devices.scatterguard import Scatterguard
 
@@ -105,7 +105,9 @@ class ApertureScatterguard(StandardReadable, Movable):
     ) -> None:
         self.aperture = Aperture(prefix + "-MO-MAPT-01:")
         self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
-        self.radius = soft_signal_rw(float, units="µm")
+        self.radius = create_hardware_backed_soft_signal(
+            float, self._get_current_radius, units="µm"
+        )
         self._loaded_positions = loaded_positions
         self._tolerances = tolerances
         self.add_readables(
@@ -119,7 +121,9 @@ class ApertureScatterguard(StandardReadable, Movable):
             ],
         )
         with self.add_children_as_readables(HintedSignal):
-            self.selected_aperture = soft_signal_rw(ApertureValue)
+            self.selected_aperture = create_hardware_backed_soft_signal(
+                ApertureValue, self._get_current_aperture_position
+            )
 
         super().__init__(name)
 
@@ -136,9 +140,6 @@ class ApertureScatterguard(StandardReadable, Movable):
     @AsyncStatus.wrap
     async def _set_raw_unsafe(self, position: AperturePosition):
         """Accept the risks and move in an unsafe way. Collisions possible."""
-        if position.radius is not None:
-            await self.radius.set(position.radius)
-
         aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
             position.values
         )
@@ -150,13 +151,8 @@ class ApertureScatterguard(StandardReadable, Movable):
             self.scatterguard.x.set(scatterguard_x),
             self.scatterguard.y.set(scatterguard_y),
         )
-        try:
-            value = await self.get_current_aperture_position()
-            self.selected_aperture.set(value)
-        except InvalidApertureMove:
-            self.selected_aperture.set(None)  # type: ignore
 
-    async def get_current_aperture_position(self) -> ApertureValue:
+    async def _get_current_aperture_position(self) -> ApertureValue:
         """
         Returns the current aperture position using readback values
         for SMALL, MEDIUM, LARGE. ROBOT_LOAD position defined when
@@ -176,6 +172,10 @@ class ApertureScatterguard(StandardReadable, Movable):
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
 
+    async def _get_current_radius(self) -> float | None:
+        current_value = await self._get_current_aperture_position()
+        return self._loaded_positions[current_value].radius
+
     async def _safe_move_within_datacollection_range(
         self, position: AperturePosition, value: ApertureValue
     ):
@@ -203,8 +203,6 @@ class ApertureScatterguard(StandardReadable, Movable):
             )
 
         current_ap_y = await self.aperture.y.user_readback.get_value()
-        if position.radius is not None:
-            await self.radius.set(position.radius)
 
         aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
             position.values
@@ -231,4 +229,3 @@ class ApertureScatterguard(StandardReadable, Movable):
                 self.scatterguard.x.set(scatterguard_x),
                 self.scatterguard.y.set(scatterguard_y),
             )
-        await self.selected_aperture.set(value)

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/src/dodal/devices/oav/oav_detector.py

@@ -12,7 +12,6 @@ from ophyd import (
     OverlayPlugin,
     ProcessPlugin,
     ROIPlugin,
-    Signal,
     StatusBase,
 )
 
@@ -35,8 +34,6 @@ class ZoomController(Device):
 
     # Level is the string description of the zoom level e.g. "1.0x"
     level = Component(EpicsSignal, "MP:SELECT", string=True)
-    # Used by OAV to work out if we're changing the setpoint
-    _level_sp = Component(Signal)
 
     zrst = Component(EpicsSignal, "MP:SELECT.ZRST")
     onst = Component(EpicsSignal, "MP:SELECT.ONST")
@@ -46,14 +43,6 @@ class ZoomController(Device):
     fvst = Component(EpicsSignal, "MP:SELECT.FVST")
     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(
-            flat_applied if value == "1.0x" else no_flat_applied
-        )
-
     @property
     def allowed_zoom_levels(self):
         return [
@@ -67,10 +56,7 @@ class ZoomController(Device):
         ]
 
     def set(self, level_to_set: str) -> StatusBase:
-        return_status = self._level_sp.set(level_to_set)
-        return_status &= self.level.set(level_to_set)
-        return_status &= self.set_flatfield_on_zoom_level_one(level_to_set)
-        return return_status
+        return self.level.set(level_to_set)
 
 
 class OAV(AreaDetector):

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/tests/devices/unit_tests/oav/test_oav.py

@@ -1,8 +1,5 @@
-from unittest.mock import MagicMock
-
 import pytest
 from ophyd.sim import instantiate_fake_device
-from ophyd.status import AndStatus, Status
 
 from dodal.devices.oav.oav_detector import OAV, OAVConfigParams
 from dodal.devices.oav.oav_errors import (
@@ -36,32 +33,6 @@ def oav() -> OAV:
     return oav
 
 
-@pytest.mark.parametrize(
-    "zoom, expected_plugin",
-    [
-        ("1.0x", "proc"),
-        ("7.0x", "CAM"),
-    ],
-)
-def test_when_zoom_level_changed_then_oav_rewired(zoom, expected_plugin, oav: OAV):
-    oav.zoom_controller.set(zoom).wait()
-
-    assert oav.grid_snapshot.input_plugin.get() == expected_plugin
-
-
-def test_when_zoom_level_changed_then_status_waits_for_all_plugins_to_be_updated(
-    oav: OAV,
-):
-    mjpg_status = Status("mjpg - test_when_zoom_level...")
-    oav.grid_snapshot.input_plugin.set = MagicMock(return_value=mjpg_status)
-
-    assert isinstance(full_status := oav.zoom_controller.set("1.0x"), AndStatus)
-    assert mjpg_status in full_status
-
-    mjpg_status.set_finished()
-    full_status.wait()
-
-
 def test_load_microns_per_pixel_entry_not_found(oav: OAV):
     with pytest.raises(OAVError_ZoomLevelNotFound):
         oav.parameters.load_microns_per_pixel(0.000001, 0, 0)

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/tests/devices/unit_tests/test_aperture_scatterguard.py

@@ -8,6 +8,7 @@ import pytest
 from bluesky.run_engine import RunEngine
 from ophyd_async.core import (
     DeviceCollector,
+    callback_on_mock_put,
     get_mock_put,
     set_mock_value,
 )
@@ -115,6 +116,7 @@ async def aperture_in_medium_pos_w_call_log(
     await ap_sg._set_raw_unsafe(aperture_positions[ApertureValue.MEDIUM])
 
     set_mock_value(ap_sg.aperture.medium, 1)
+
     yield ap_sg, call_log
 
 
@@ -144,9 +146,6 @@ def _assert_position_in_reading(
     position: AperturePosition,
     device_name: str,
 ):
-    if position.radius is not None:
-        assert reading[f"{device_name}-radius"]["value"] == position.radius
-    assert reading[f"{device_name}-selected_aperture"]["value"] == aperture
     assert reading[f"{device_name}-aperture-x"]["value"] == position.aperture_x
     assert reading[f"{device_name}-aperture-y"]["value"] == position.aperture_y
     assert reading[f"{device_name}-aperture-z"]["value"] == position.aperture_z
@@ -244,19 +243,27 @@ def set_underlying_motors(ap_sg: ApertureScatterguard, position: AperturePositio
         motor.set(pos)
 
 
-async def test_aperture_positions_large(ap_sg: ApertureScatterguard):
-    set_mock_value(ap_sg.aperture.large, 1)
-    assert await ap_sg.get_current_aperture_position() == ApertureValue.LARGE
-
-
-async def test_aperture_positions_medium(ap_sg: ApertureScatterguard):
-    set_mock_value(ap_sg.aperture.medium, 1)
-    assert await ap_sg.get_current_aperture_position() == ApertureValue.MEDIUM
-
-
-async def test_aperture_positions_small(ap_sg: ApertureScatterguard):
-    set_mock_value(ap_sg.aperture.small, 1)
-    assert await ap_sg.get_current_aperture_position() == ApertureValue.SMALL
+@pytest.mark.parametrize(
+    "read_pv, aperture",
+    [
+        ("large", ApertureValue.LARGE),
+        ("medium", ApertureValue.MEDIUM),
+        ("small", ApertureValue.SMALL),
+    ],
+)
+async def test_aperture_positions(
+    ap_sg: ApertureScatterguard,
+    aperture_positions: dict[ApertureValue, AperturePosition],
+    read_pv: str,
+    aperture: ApertureValue,
+):
+    set_mock_value(getattr(ap_sg.aperture, read_pv), 1)
+    reading = await ap_sg.read()
+    assert isinstance(reading, dict)
+    assert (
+        reading[f"{ap_sg.name}-radius"]["value"] == aperture_positions[aperture].radius
+    )
+    assert reading[f"{ap_sg.name}-selected_aperture"]["value"] == aperture
 
 
 async def test_aperture_positions_robot_load(
@@ -268,7 +275,12 @@ async def test_aperture_positions_robot_load(
     set_mock_value(ap_sg.aperture.small, 0)
     robot_load = aperture_positions[ApertureValue.ROBOT_LOAD]
     await ap_sg.aperture.y.set(robot_load.aperture_y)
-    assert await ap_sg.get_current_aperture_position() == ApertureValue.ROBOT_LOAD
+    reading = await ap_sg.read()
+    assert isinstance(reading, dict)
+    assert reading[f"{ap_sg.name}-radius"]["value"] == 0.0
+    assert (
+        reading[f"{ap_sg.name}-selected_aperture"]["value"] == ApertureValue.ROBOT_LOAD
+    )
 
 
 async def test_aperture_positions_robot_load_within_tolerance(
@@ -282,7 +294,12 @@ async def test_aperture_positions_robot_load_within_tolerance(
     set_mock_value(ap_sg.aperture.medium, 0)
     set_mock_value(ap_sg.aperture.small, 0)
     await ap_sg.aperture.y.set(robot_load_ap_y + tolerance)
-    assert await ap_sg.get_current_aperture_position() == ApertureValue.ROBOT_LOAD
+    reading = await ap_sg.read()
+    assert isinstance(reading, dict)
+    assert reading[f"{ap_sg.name}-radius"]["value"] == 0.0
+    assert (
+        reading[f"{ap_sg.name}-selected_aperture"]["value"] == ApertureValue.ROBOT_LOAD
+    )
 
 
 async def test_aperture_positions_robot_load_outside_tolerance(
@@ -297,7 +314,7 @@ async def test_aperture_positions_robot_load_outside_tolerance(
     set_mock_value(ap_sg.aperture.small, 0)
     await ap_sg.aperture.y.set(robot_load_ap_y + tolerance)
     with pytest.raises(InvalidApertureMove):
-        await ap_sg.get_current_aperture_position()
+        await ap_sg.read()
 
 
 async def test_aperture_positions_robot_load_unsafe(
@@ -308,7 +325,7 @@ async def test_aperture_positions_robot_load_unsafe(
     set_mock_value(ap_sg.aperture.small, 0)
     await ap_sg.aperture.y.set(50.0)
     with pytest.raises(InvalidApertureMove):
-        await ap_sg.get_current_aperture_position()
+        await ap_sg.read()
 
 
 @pytest.mark.skip(
@@ -360,6 +377,14 @@ async def test_ap_sg_in_runengine(
     ap = aperture_in_medium_pos.aperture
     sg = aperture_in_medium_pos.scatterguard
     test_loc = aperture_positions[ApertureValue.SMALL]
+
+    def set_small_readback_pv(value, *args, **kwargs):
+        set_mock_value(ap.small, 1)
+        set_mock_value(ap.medium, 0)
+        set_mock_value(ap.y.user_readback, value)
+
+    callback_on_mock_put(ap.y.user_setpoint, set_small_readback_pv)
+
     RE(bps.abs_set(aperture_in_medium_pos, ApertureValue.SMALL, wait=True))
     assert await ap.x.user_readback.get_value() == test_loc.aperture_x
     assert await ap.y.user_readback.get_value() == test_loc.aperture_y

{dls_dodal-1.32.0 → dls_dodal-1.33.0}/tests/devices/unit_tests/test_oav.py

@@ -2,7 +2,6 @@ from unittest.mock import AsyncMock, MagicMock, call, patch
 
 import numpy as np
 import pytest
-from bluesky import plan_stubs as bps
 from bluesky.run_engine import RunEngine
 from ophyd.sim import instantiate_fake_device, make_fake_device
 from ophyd_async.core import set_mock_value
@@ -165,27 +164,6 @@ def test_bottom_right_from_top_left():
     assert bottom_right[0] == 198 and bottom_right[1] == 263
 
 
-def test_when_zoom_1_then_flat_field_applied(fake_oav: OAV, RE: RunEngine):
-    RE(bps.abs_set(fake_oav.zoom_controller, "1.0x"))
-    assert fake_oav.grid_snapshot.input_plugin.get() == "PROC"
-
-
-def test_when_zoom_not_1_then_flat_field_removed(fake_oav: OAV, RE: RunEngine):
-    RE(bps.abs_set(fake_oav.zoom_controller, "10.0x"))
-    assert fake_oav.grid_snapshot.input_plugin.get() == "CAM"
-
-
-def test_when_zoom_is_externally_changed_to_1_then_flat_field_not_changed(
-    fake_oav: OAV,
-):
-    """This test is required to ensure that Hyperion doesn't cause unexpected behaviour
-    e.g. change the flatfield when the zoom level is changed through the synoptic"""
-    fake_oav.grid_snapshot.input_plugin.sim_put("CAM")  # type: ignore
-
-    fake_oav.zoom_controller.level.sim_put("1.0x")  # type: ignore
-    assert fake_oav.grid_snapshot.input_plugin.get() == "CAM"
-
-
 def test_get_beam_position_from_zoom_only_called_once_on_multiple_connects(
     fake_oav: OAV,
 ):