dls-dodal 1.29.4__py3-none-any.whl → 1.31.0__py3-none-any.whl

dodal/devices/util/save_panda.py

@@ -0,0 +1,87 @@
+import argparse
+import os
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import cast
+
+from bluesky.run_engine import RunEngine
+from ophyd_async.core import Device, save_device
+from ophyd_async.fastcs.panda import phase_sorter
+
+from dodal.beamlines import module_name_for_beamline
+from dodal.utils import make_device
+
+
+def main(argv: list[str]):
+    """CLI Utility to save the panda configuration."""
+    parser = ArgumentParser(description="Save an ophyd_async panda to yaml")
+    parser.add_argument(
+        "--beamline", help="beamline to save from e.g. i03. Defaults to BEAMLINE"
+    )
+    parser.add_argument(
+        "--device-name",
+        help='name of the device. The default is "panda"',
+        default="panda",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        action=argparse.BooleanOptionalAction,
+        help="Force overwriting an existing file",
+    )
+    parser.add_argument("output_file", help="output filename")
+
+    # this exit()s with message/help unless args parsed successfully
+    args = parser.parse_args(argv[1:])
+
+    beamline = args.beamline
+    device_name = args.device_name
+    output_file = args.output_file
+    force = args.force
+
+    if beamline:
+        os.environ["BEAMLINE"] = beamline
+    else:
+        beamline = os.environ.get("BEAMLINE", None)
+
+    if not beamline:
+        sys.stderr.write("BEAMLINE not set and --beamline not specified\n")
+        return 1
+
+    if Path(output_file).exists() and not force:
+        sys.stderr.write(
+            f"Output file {output_file} already exists and --force not specified."
+        )
+        return 1
+
+    _save_panda(beamline, device_name, output_file)
+
+    print("Done.")
+    return 0
+
+
+def _save_panda(beamline, device_name, output_file):
+    RE = RunEngine()
+    print("Creating devices...")
+    module_name = module_name_for_beamline(beamline)
+    try:
+        devices = make_device(f"dodal.beamlines.{module_name}", device_name)
+    except Exception as error:
+        sys.stderr.write(f"Couldn't create device {device_name}: {error}\n")
+        sys.exit(1)
+
+    panda = devices[device_name]
+    print(f"Saving to {output_file} from {device_name} on {beamline}...")
+    _save_panda_to_file(RE, cast(Device, panda), output_file)
+
+
+def _save_panda_to_file(RE: RunEngine, panda: Device, path: str):
+    def save_to_file():
+        yield from save_device(panda, path, sorter=phase_sorter)
+
+    RE(save_to_file())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main(sys.argv))

dodal/devices/util/test_utils.py

@@ -0,0 +1,17 @@
+from ophyd_async.core import (
+    callback_on_mock_put,
+    set_mock_value,
+)
+from ophyd_async.epics.motor import Motor
+
+
+def patch_motor(motor: Motor, initial_position=0):
+    set_mock_value(motor.user_setpoint, initial_position)
+    set_mock_value(motor.user_readback, initial_position)
+    set_mock_value(motor.deadband, 0.001)
+    set_mock_value(motor.motor_done_move, 1)
+    set_mock_value(motor.velocity, 3)
+    return callback_on_mock_put(
+        motor.user_setpoint,
+        lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),
+    )

dodal/devices/webcam.py

@@ -3,7 +3,7 @@ from pathlib import Path
 import aiofiles
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_rw
+from ophyd_async.core import AsyncStatus, HintedSignal, StandardReadable, soft_signal_rw
 
 from dodal.log import LOGGER
 
@@ -15,7 +15,7 @@ class Webcam(StandardReadable, Triggerable):
         self.directory = soft_signal_rw(str, name="directory")
         self.last_saved_path = soft_signal_rw(str, name="last_saved_path")
 
-        self.set_readable_signals([self.last_saved_path])
+        self.add_readables([self.last_saved_path], wrapper=HintedSignal)
         super().__init__(name=name)
 
     async def _write_image(self, file_path: str):
@@ -24,7 +24,7 @@ class Webcam(StandardReadable, Triggerable):
                 response.raise_for_status()
                 LOGGER.info(f"Saving webcam image from {self.url} to {file_path}")
                 async with aiofiles.open(file_path, "wb") as file:
-                    await file.write((await response.read()))
+                    await file.write(await response.read())
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:

dodal/devices/xbpm_feedback.py

@@ -1,11 +1,7 @@
 from enum import Enum
 
-import ophyd
 from bluesky.protocols import Triggerable
-from ophyd import Component, EpicsSignal, EpicsSignalRO
-from ophyd.status import StatusBase, SubscriptionStatus
-from ophyd_async.core import Device, observe_value
-from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core import AsyncStatus, Device, observe_value
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 
@@ -31,23 +27,3 @@ class XBPMFeedback(Device, Triggerable):
         async for value in observe_value(self.pos_stable):
             if value:
                 return
-
-
-class XBPMFeedbackI04(ophyd.Device):
-    """The I04 version of this device has a slightly different trigger method"""
-
-    # Values to set to pause_feedback
-    PAUSE = 0
-    RUN = 1
-
-    pos_ok = Component(EpicsSignalRO, "-EA-FDBK-01:XBPM2POSITION_OK")
-    pause_feedback = Component(EpicsSignal, "-EA-FDBK-01:FB_PAUSE")
-    x = Component(EpicsSignalRO, "-EA-XBPM-02:PosX:MeanValue_RBV")
-    y = Component(EpicsSignalRO, "-EA-XBPM-02:PosY:MeanValue_RBV")
-
-    def trigger(self) -> StatusBase:
-        return SubscriptionStatus(
-            self.pos_ok,
-            lambda *, old_value, value, **kwargs: value == 1,
-            timeout=60,
-        )

dodal/devices/xspress3/xspress3.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     DeviceVector,
     wait_for_value,
 )
-from ophyd_async.epics.signal.signal import (
+from ophyd_async.epics.signal import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,

dodal/devices/zebra.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 from enum import Enum
 from functools import partialmethod
-from typing import List
 
 from ophyd_async.core import (
     AsyncStatus,
@@ -38,6 +37,11 @@ TTL_SHUTTER = 2
 TTL_XSPRESS3 = 3
 TTL_PANDA = 4
 
+# The AND gate that controls the automatic shutter
+AUTO_SHUTTER_GATE = 2
+# The input that triggers the automatic shutter
+AUTO_SHUTTER_INPUT = 1
+
 
 class ArmSource(str, Enum):
     SOFT = "Soft"
@@ -95,7 +99,7 @@ class ArmingDevice(StandardReadable):
     """A useful device that can abstract some of the logic of arming.
     Allows a user to just call arm.set(ArmDemand.ARM)"""
 
-    TIMEOUT = 3
+    TIMEOUT: float = 3
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.arm_set = epics_signal_rw(float, prefix + "PC_ARM")
@@ -110,10 +114,9 @@ class ArmingDevice(StandardReadable):
             if reading == demand.value:
                 return
 
-    def set(self, demand: ArmDemand) -> AsyncStatus:
-        return AsyncStatus(
-            asyncio.wait_for(self._set_armed(demand), timeout=self.TIMEOUT)
-        )
+    @AsyncStatus.wrap
+    async def set(self, demand: ArmDemand):
+        await asyncio.wait_for(self._set_armed(demand), timeout=self.TIMEOUT)
 
 
 class PositionCompare(StandardReadable):
@@ -166,7 +169,7 @@ class ZebraOutputPanel(StandardReadable):
         super().__init__(name)
 
 
-def boolean_array_to_integer(values: List[bool]) -> int:
+def boolean_array_to_integer(values: list[bool]) -> int:
     """Converts a boolean array to integer by interpretting it in binary with LSB 0 bit
     numbering.
 
@@ -245,8 +248,8 @@ class LogicGateConfiguration:
     NUMBER_OF_INPUTS = 4
 
     def __init__(self, input_source: int, invert: bool = False) -> None:
-        self.sources: List[int] = []
-        self.invert: List[bool] = []
+        self.sources: list[int] = []
+        self.invert: list[bool] = []
         self.add_input(input_source, invert)
 
     def add_input(
@@ -271,7 +274,9 @@ class LogicGateConfiguration:
 
     def __str__(self) -> str:
         input_strings = []
-        for input, (source, invert) in enumerate(zip(self.sources, self.invert)):
+        for input, (source, invert) in enumerate(
+            zip(self.sources, self.invert, strict=False)
+        ):
             input_strings.append(f"INP{input+1}={'!' if invert else ''}{source}")
 
         return ", ".join(input_strings)

dodal/devices/zebra_controlled_shutter.py

@@ -7,7 +7,7 @@ from ophyd_async.core import (
     StandardReadable,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_w
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_w
 
 
 class ZebraShutterState(str, Enum):
@@ -15,24 +15,39 @@ class ZebraShutterState(str, Enum):
     OPEN = "Open"
 
 
+class ZebraShutterControl(str, Enum):
+    MANUAL = "Manual"
+    AUTO = "Auto"
+
+
 class ZebraShutter(StandardReadable, Movable):
+    """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
+    automatic control. A soft input (aliased to control_mode) will switch between
+    which of these AND gates to use. For the manual gate the shutter is then controlled
+    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):
-        self.position_setpoint = epics_signal_w(
-            write_pv=prefix + "CTRL2",
-            datatype=ZebraShutterState,
+        self._manual_position_setpoint = epics_signal_w(
+            ZebraShutterState, prefix + "CTRL2"
         )
+        self.control_mode = epics_signal_rw(ZebraShutterControl, prefix + "CTRL1")
+
         with self.add_children_as_readables():
-            self.position_readback = epics_signal_r(
-                read_pv=prefix + "STA",
-                datatype=ZebraShutterState,
-            )
+            self.position_readback = epics_signal_r(ZebraShutterState, prefix + "STA")
         super().__init__(name=name)
 
     @AsyncStatus.wrap
-    async def set(self, desired_position: ZebraShutterState):
-        await self.position_setpoint.set(desired_position)
+    async def set(self, value: ZebraShutterState):
+        if await self.control_mode.get_value() == ZebraShutterControl.AUTO:
+            raise UserWarning(
+                f"Tried to set shutter to {value.value} but the shutter is in auto mode."
+            )
+        await self._manual_position_setpoint.set(value)
         return await wait_for_value(
             signal=self.position_readback,
-            match=desired_position,
+            match=value,
             timeout=DEFAULT_TIMEOUT,
         )

dodal/devices/zocalo/zocalo_interaction.py

@@ -1,5 +1,6 @@
 import dataclasses
 import getpass
+import os
 import socket
 from dataclasses import dataclass
 
@@ -37,6 +38,12 @@ class ZocaloStartInfo:
     message_index: int
 
 
+def _get_zocalo_headers() -> tuple[str, str]:
+    user = os.environ.get("ZOCALO_GO_USER", getpass.getuser())
+    hostname = os.environ.get("ZOCALO_GO_HOSTNAME", socket.gethostname())
+    return user, hostname
+
+
 class ZocaloTrigger:
     """This class just sends 'run_start' and 'run_end' messages to zocalo, it is
     intended to be used in bluesky callback classes. To get results from zocalo back
@@ -55,9 +62,10 @@ class ZocaloTrigger:
                 "recipes": ["mimas"],
                 "parameters": parameters,
             }
+            user, hostname = _get_zocalo_headers()
             header = {
-                "zocalo.go.user": getpass.getuser(),
-                "zocalo.go.host": socket.gethostname(),
+                "zocalo.go.user": user,
+                "zocalo.go.host": hostname,
             }
             transport.send("processing_recipe", message, headers=header)
         finally:

dodal/devices/zocalo/zocalo_results.py

@@ -1,8 +1,9 @@
 import asyncio
 from collections import OrderedDict
+from collections.abc import Generator, Sequence
 from enum import Enum
 from queue import Empty, Queue
-from typing import Any, Generator, Sequence, Tuple, TypedDict
+from typing import Any, TypedDict
 
 import bluesky.plan_stubs as bps
 import numpy as np
@@ -10,8 +11,12 @@ import workflows.recipe
 import workflows.transport
 from bluesky.protocols import Descriptor, Triggerable
 from numpy.typing import NDArray
-from ophyd_async.core import StandardReadable, soft_signal_r_and_setter
-from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core import (
+    AsyncStatus,
+    HintedSignal,
+    StandardReadable,
+    soft_signal_r_and_setter,
+)
 from workflows.transport.common_transport import CommonTransport
 
 from dodal.devices.zocalo.zocalo_interaction import _get_zocalo_connection
@@ -79,34 +84,41 @@ class ZocaloResults(StandardReadable, Triggerable):
         self._raw_results_received: Queue = Queue()
         self.transport: CommonTransport | None = None
 
-        self.results, _ = soft_signal_r_and_setter(list[XrcResult], name="results")
-        self.centres_of_mass, _ = soft_signal_r_and_setter(
+        self.results, self._results_setter = soft_signal_r_and_setter(
+            list[XrcResult], name="results"
+        )
+        self.centres_of_mass, self._com_setter = soft_signal_r_and_setter(
             NDArray[np.uint64], name="centres_of_mass"
         )
-        self.bbox_sizes, _ = soft_signal_r_and_setter(
+        self.bbox_sizes, self._bbox_setter = soft_signal_r_and_setter(
             NDArray[np.uint64], "bbox_sizes", self.name
         )
-        self.ispyb_dcid, _ = soft_signal_r_and_setter(int, name="ispyb_dcid")
-        self.ispyb_dcgid, _ = soft_signal_r_and_setter(int, name="ispyb_dcgid")
-        self.set_readable_signals(
-            read=[
+        self.ispyb_dcid, self._ispyb_dcid_setter = soft_signal_r_and_setter(
+            int, name="ispyb_dcid"
+        )
+        self.ispyb_dcgid, self._ispyb_dcgid_setter = soft_signal_r_and_setter(
+            int, name="ispyb_dcgid"
+        )
+        self.add_readables(
+            [
                 self.results,
                 self.centres_of_mass,
                 self.bbox_sizes,
                 self.ispyb_dcid,
                 self.ispyb_dcgid,
-            ]
+            ],
+            wrapper=HintedSignal,
         )
         super().__init__(name)
 
     async def _put_results(self, results: Sequence[XrcResult], ispyb_ids):
-        await self.results._backend.put(list(results))
+        self._results_setter(list(results))
         centres_of_mass = np.array([r["centre_of_mass"] for r in results])
         bbox_sizes = np.array([bbox_size(r) for r in results])
-        await self.centres_of_mass._backend.put(centres_of_mass)
-        await self.bbox_sizes._backend.put(bbox_sizes)
-        await self.ispyb_dcid._backend.put(ispyb_ids["dcid"])
-        await self.ispyb_dcgid._backend.put(ispyb_ids["dcgid"])
+        self._com_setter(centres_of_mass)
+        self._bbox_setter(bbox_sizes)
+        self._ispyb_dcid_setter(ispyb_ids["dcid"])
+        self._ispyb_dcgid_setter(ispyb_ids["dcgid"])
 
     def _clear_old_results(self):
         LOGGER.info("Clearing queue")
@@ -120,7 +132,12 @@ class ZocaloResults(StandardReadable, Triggerable):
         before triggering processing for the experiment"""
 
         LOGGER.info("Subscribing to results queue")
-        self._subscribe_to_results()
+        try:
+            self._subscribe_to_results()
+        except Exception as e:
+            print(f"GOT {e}")
+            raise
+
         await asyncio.sleep(CLEAR_QUEUE_WAIT_S)
         self._clear_old_results()
 
@@ -152,7 +169,7 @@ class ZocaloResults(StandardReadable, Triggerable):
             )
 
             raw_results = self._raw_results_received.get(timeout=self.timeout_s)
-            LOGGER.info(f"Zocalo: found {len(raw_results)} crystals.")
+            LOGGER.info(f"Zocalo: found {len(raw_results['results'])} crystals.")
             # Sort from strongest to weakest in case of multiple crystals
             await self._put_results(
                 sorted(
@@ -242,7 +259,7 @@ class ZocaloResults(StandardReadable, Triggerable):
 
 def get_processing_result(
     zocalo: ZocaloResults,
-) -> Generator[Any, Any, Tuple[np.ndarray, np.ndarray] | Tuple[None, None]]:
+) -> Generator[Any, Any, tuple[np.ndarray, np.ndarray] | tuple[None, None]]:
     """A minimal plan which will extract the top ranked xray centre and crystal bounding
     box size from the zocalo results. Returns (None, None) if no crystals were found."""
 

dodal/log.py

@@ -6,30 +6,52 @@ from logging import Logger, StreamHandler
 from logging.handlers import TimedRotatingFileHandler
 from os import environ
 from pathlib import Path
-from typing import Deque, Tuple, TypedDict
+from typing import TypedDict
 
+import colorlog
 from bluesky.log import logger as bluesky_logger
 from graypy import GELFTCPHandler
 from ophyd.log import logger as ophyd_logger
-from ophyd_async.log import (
-    DEFAULT_DATE_FORMAT,
-    DEFAULT_FORMAT,
-    DEFAULT_LOG_COLORS,
-    ColoredFormatterWithDeviceName,
-)
-from ophyd_async.log import logger as ophyd_async_logger
 
 LOGGER = logging.getLogger("Dodal")
+# Temporarily duplicated https://github.com/bluesky/ophyd-async/issues/550
+ophyd_async_logger = logging.getLogger("ophyd_async")
 LOGGER.setLevel(logging.DEBUG)
 
-DEFAULT_FORMATTER = ColoredFormatterWithDeviceName(
-    fmt=DEFAULT_FORMAT, datefmt=DEFAULT_DATE_FORMAT, log_colors=DEFAULT_LOG_COLORS
-)
 ERROR_LOG_BUFFER_LINES = 20000
 INFO_LOG_DAYS = 30
 DEBUG_LOG_FILES_TO_KEEP = 7
 DEFAULT_GRAYLOG_PORT = 12231
 
+# Temporarily duplicated https://github.com/bluesky/ophyd-async/issues/550
+DEFAULT_FORMAT = (
+    "%(log_color)s[%(levelname)1.1s %(asctime)s.%(msecs)03d "
+    "%(module)s:%(lineno)d] %(message)s"
+)
+
+DEFAULT_DATE_FORMAT = "%y%m%d %H:%M:%S"
+
+DEFAULT_LOG_COLORS = {
+    "DEBUG": "cyan",
+    "INFO": "green",
+    "WARNING": "yellow",
+    "ERROR": "red",
+    "CRITICAL": "red,bg_white",
+}
+
+
+class ColoredFormatterWithDeviceName(colorlog.ColoredFormatter):
+    def format(self, record):
+        message = super().format(record)
+        if device_name := getattr(record, "ophyd_async_device_name", None):
+            message = f"[{device_name}]{message}"
+        return message
+
+
+DEFAULT_FORMATTER = ColoredFormatterWithDeviceName(
+    fmt=DEFAULT_FORMAT, datefmt=DEFAULT_DATE_FORMAT, log_colors=DEFAULT_LOG_COLORS
+)
+
 
 class CircularMemoryHandler(logging.Handler):
     """Loosely based on the MemoryHandler, which keeps a buffer and writes it when full
@@ -37,11 +59,14 @@ class CircularMemoryHandler(logging.Handler):
     that always contains the last {capacity} number of messages, this is only flushed
     when a log of specific {flushLevel} comes in. On flush this buffer is then passed to
     the {target} handler.
+
+    The CircularMemoryHandler becomes the owner of the target handler which will be closed
+    on close of this handler.
     """
 
     def __init__(self, capacity, flushLevel=logging.ERROR, target=None):
         logging.Handler.__init__(self)
-        self.buffer: Deque[logging.LogRecord] = deque(maxlen=capacity)
+        self.buffer: deque[logging.LogRecord] = deque(maxlen=capacity)
         self.flushLevel = flushLevel
         self.target = target
 
@@ -66,6 +91,12 @@ class CircularMemoryHandler(logging.Handler):
         self.acquire()
         try:
             self.buffer.clear()
+            if self.target:
+                self.target.acquire()
+                try:
+                    self.target.close()
+                finally:
+                    self.target.release()
             self.target = None
             logging.Handler.close(self)
         finally:
@@ -121,7 +152,7 @@ def set_up_graylog_handler(logger: Logger, host: str, port: int):
 def set_up_INFO_file_handler(logger, path: Path, filename: str):
     """Set up a file handler for the logger, at INFO level, which will keep 30 days
     of logs, rotating once per day. Creates the directory if necessary."""
-    print(f"Logging to {path/filename}")
+    print(f"Logging to INFO file handler {path/filename}")
     path.mkdir(parents=True, exist_ok=True)
     file_handler = TimedRotatingFileHandler(
         filename=path / filename, when="MIDNIGHT", backupCount=INFO_LOG_DAYS
@@ -137,8 +168,8 @@ def set_up_DEBUG_memory_handler(
     """Set up a Memory handler which holds 200k lines, and writes them to an hourly
     log file when it sees a message of severity ERROR. Creates the directory if
     necessary"""
-    print(f"Logging to {path/filename}")
     debug_path = path / "debug"
+    print(f"Logging to DEBUG handler {debug_path/filename}")
     debug_path.mkdir(parents=True, exist_ok=True)
     file_handler = TimedRotatingFileHandler(
         filename=debug_path / filename, when="H", backupCount=DEBUG_LOG_FILES_TO_KEEP
@@ -240,7 +271,7 @@ def get_logging_file_path() -> Path:
 
 def get_graylog_configuration(
     dev_mode: bool, graylog_port: int | None = None
-) -> Tuple[str, int]:
+) -> tuple[str, int]:
     """Get the host and port for the graylog handler.
 
     If running in dev mode, this switches to localhost. Otherwise it publishes to the

dodal/plans/check_topup.py

@@ -1,5 +1,10 @@
+from typing import Any
+
 import bluesky.plan_stubs as bps
 
+from dodal.common.beamlines.beamline_parameters import (
+    get_beamline_parameters,
+)
 from dodal.devices.synchrotron import Synchrotron, SynchrotronMode
 from dodal.log import LOGGER
 
@@ -7,6 +12,20 @@ ALLOWED_MODES = [SynchrotronMode.USER, SynchrotronMode.SPECIAL]
 DECAY_MODE_COUNTDOWN = -1  # Value of the start_countdown PV when in decay mode
 COUNTDOWN_DURING_TOPUP = 0
 
+DEFAULT_THRESHOLD_EXPOSURE_S = 120
+DEFAULT_TOPUP_GATE_DELAY_S = 1
+
+
+class TopupConfig:
+    # For planned exposures less than this value, wait for topup to finish instead of
+    # collecting throughout topup.
+    THRESHOLD_EXPOSURE_S = "dodal_topup_threshold_exposure_s"
+    # Additional configurable safety margin to wait after the end of topup, as the start
+    # and end countdowns do not have the same precision, and in addition we want to be sure
+    # that collection does not overlap with any transients that may occur after the
+    # nominal endpoint.
+    TOPUP_GATE_DELAY_S = "dodal_topup_end_delay_s"
+
 
 def _in_decay_mode(time_to_topup):
     if time_to_topup == DECAY_MODE_COUNTDOWN:
@@ -23,15 +42,38 @@ def _gating_permitted(machine_mode: SynchrotronMode):
     return False
 
 
-def _delay_to_avoid_topup(total_run_time, time_to_topup):
-    if total_run_time > time_to_topup:
-        LOGGER.info(
-            """
-            Total run time for this collection exceeds time to next top up.
-            Collection delayed until top up done.
-            """
+def _delay_to_avoid_topup(
+    total_run_time_s: float,
+    time_to_topup_s: float,
+    topup_configuration: dict,
+    total_exposure_time_s: float,
+) -> bool:
+    """Determine whether we should delay collection until after a topup. Generally
+    if a topup is due to occur during the collection we will delay collection until after the topup.
+    However for long-running collections, impact of the topup is potentially less and collection-duration may be
+    a significant fraction of the topup-interval, therefore we may wish to collect during a topup.
+
+    Args:
+        total_run_time_s: Anticipated time until end of the collection in seconds
+        time_to_topup_s: Time to the start of the topup as measured from the PV
+        topup_configuration: configuration dictionary
+        total_exposure_time_s: Total exposure time of the sample in s"""
+    if total_run_time_s > time_to_topup_s:
+        limit_s = topup_configuration.get(
+            TopupConfig.THRESHOLD_EXPOSURE_S, DEFAULT_THRESHOLD_EXPOSURE_S
         )
-        return True
+        gate = total_exposure_time_s < limit_s
+        if gate:
+            LOGGER.info(f"""
+                Exposure time of {total_exposure_time_s}s below the threshold of {limit_s}s.
+                Collection delayed until topup done.
+                """)
+        else:
+            LOGGER.info(f"""
+                Exposure time of {total_exposure_time_s}s meets the threshold of {limit_s}s.
+                Collection proceeding through topup.
+                """)
+        return gate
     LOGGER.info(
         """
         Total run time less than time to next topup. Proceeding with collection.
@@ -71,12 +113,25 @@ def check_topup_and_wait_if_necessary(
         return
     tot_run_time = total_exposure_time + ops_time
     end_topup = yield from bps.rd(synchrotron.top_up_end_countdown)
-    time_to_wait = (
-        end_topup if _delay_to_avoid_topup(tot_run_time, time_to_topup) else 0.0
+    topup_configuration = _load_topup_configuration_from_properties_file()
+    should_wait = _delay_to_avoid_topup(
+        tot_run_time,
+        time_to_topup,
+        topup_configuration,
+        total_exposure_time,
+    )
+    topup_gate_delay = topup_configuration.get(
+        TopupConfig.TOPUP_GATE_DELAY_S, DEFAULT_TOPUP_GATE_DELAY_S
     )
+    time_to_wait = end_topup + topup_gate_delay if should_wait else 0.0
 
     yield from bps.sleep(time_to_wait)
 
     check_start = yield from bps.rd(synchrotron.top_up_start_countdown)
     if check_start == COUNTDOWN_DURING_TOPUP:
         yield from wait_for_topup_complete(synchrotron)
+
+
+def _load_topup_configuration_from_properties_file() -> dict[str, Any]:
+    params = get_beamline_parameters()
+    return params.params