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

dodal/devices/zocalo/zocalo_results.py

@@ -11,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 HintedSignal, 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

dodal/log.py

@@ -8,28 +8,50 @@ from os import environ
 from pathlib import Path
 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

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

dodal/plans/data_session_metadata.py

@@ -1,29 +1,28 @@
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import make_decorator
-from ophyd_async.core import DirectoryInfo
 
 from dodal.common.beamlines import beamline_utils
-from dodal.common.types import MsgGenerator, UpdatingDirectoryProvider
+from dodal.common.types import MsgGenerator, UpdatingPathProvider
 
 DATA_SESSION = "data_session"
 DATA_GROUPS = "data_groups"
 
 
 def attach_data_session_metadata_wrapper(
-    plan: MsgGenerator, provider: UpdatingDirectoryProvider | None = None
+    plan: MsgGenerator, provider: UpdatingPathProvider | None = None
 ) -> MsgGenerator:
     """
     Attach data session metadata to the runs within a plan and make it correlate
-    with an ophyd-async DirectoryProvider.
+    with an ophyd-async PathProvider.
 
-    This updates the directory provider (which in turn makes a call to to a service
+    This updates the path provider (which in turn makes a call to to a service
     to figure out which scan number we are using for such a scan), and ensures the
     start document contains the correct data session.
 
     Args:
         plan: The plan to preprocess
-        provider: The directory provider that participating detectors are aware of.
+        provider: The path provider that participating detectors are aware of.
 
     Returns:
         MsgGenerator: A plan
@@ -32,13 +31,12 @@ def attach_data_session_metadata_wrapper(
         Iterator[Msg]: Plan messages
     """
     if provider is None:
-        provider = beamline_utils.get_directory_provider()
+        provider = beamline_utils.get_path_provider()
     yield from bps.wait_for([provider.update])
-    directory_info: DirectoryInfo = provider()
+    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
-    assert directory_info.prefix is not None
-    data_session = directory_info.prefix.removesuffix("-")
     yield from bpp.inject_md_wrapper(plan, md={DATA_SESSION: data_session})
 
 

dodal/plans/motor_util_plans.py

@@ -6,7 +6,7 @@ from bluesky import plan_stubs as bps
 from bluesky.preprocessors import finalize_wrapper, pchain
 from bluesky.utils import Msg, make_decorator
 from ophyd_async.core import Device
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 from dodal.common import MsgGenerator
 

dodal/devices/beamstop.py

@@ -1,8 +0,0 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor
-
-
-class BeamStop(Device):
-    x = Cpt(EpicsMotor, "-MO-BS-01:X")
-    y = Cpt(EpicsMotor, "-MO-BS-01:Y")
-    z = Cpt(EpicsMotor, "-MO-BS-01:Z")