dls-dodal 1.35.0__py3-none-any.whl → 1.36.0__py3-none-any.whl

{dls_dodal-1.35.0.dist-info → dls_dodal-1.36.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.35.0
+Version: 1.36.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
@@ -233,11 +233,13 @@ Requires-Dist: aiofiles
 Requires-Dist: aiohttp
 Requires-Dist: redis
 Requires-Dist: deepdiff
+Requires-Dist: scanspec >=0.7.3
 Provides-Extra: dev
 Requires-Dist: black ; extra == 'dev'
 Requires-Dist: diff-cover ; extra == 'dev'
 Requires-Dist: mypy ; extra == 'dev'
 Requires-Dist: myst-parser ; extra == 'dev'
+Requires-Dist: ophyd-async[sim] ; extra == 'dev'
 Requires-Dist: pipdeptree ; extra == 'dev'
 Requires-Dist: pre-commit ; extra == 'dev'
 Requires-Dist: psutil ; extra == 'dev'

{dls_dodal-1.35.0.dist-info → dls_dodal-1.36.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 dodal/__init__.py,sha256=Ksms_WJF8LTkbm38gEpm1jBpGqcQ8NGvmb2ZJlOE1j8,198
 dodal/__main__.py,sha256=kP2S2RPitnOWpNGokjZ1Yq-1umOtp5sNOZk2B3tBPLM,111
-dodal/_version.py,sha256=q-2n6ovtbk-r5sMORN2VAFD8HDD5aIS9gRmqA5SXG40,413
+dodal/_version.py,sha256=x0utt4SxT0Rvm84NfrkoVlob-vmxNptNpw0IPhaGKKU,413
 dodal/adsim.py,sha256=OW2dcS7ciD4Yq9WFw4PN_c5Bwccrmu7R-zr-u6ZCbQM,497
 dodal/cli.py,sha256=_crmaHchxphSW8eEJB58_XZIeK82aiUv9bV7tpz-LpA,2122
 dodal/log.py,sha256=0to7CRsbzbgVfAAfKRAMhsaUuKqF2-7CGdQc-z8Uhno,9499
@@ -45,7 +45,7 @@ dodal/devices/backlight.py,sha256=nQIr3J-I-OXnOUoWmr3ruy3nhq_q2US1KXC4NrGG_2U,16
 dodal/devices/cryostream.py,sha256=K-ldpredpeDTzNt4qtQMg99nKJNjBYoXBbK0WJGexzw,656
 dodal/devices/dcm.py,sha256=cc531sQbed1yX6pWhizUvszLhQczWatMYMZ3cEp3FHA,2559
 dodal/devices/diamond_filter.py,sha256=A--RHd7WuH-IBhvCyENcRCTP4K-mm_Kqpa0pojpHZow,1098
-dodal/devices/eiger.py,sha256=2ZT2oQiZFLprg3CjsHRkXfxt9kSf8z8uUKH1Z5n3Hzo,14107
+dodal/devices/eiger.py,sha256=VGGgkSz8AzSOP3rpehs2GwPHnOGz0OKsRP6U_FYbBA4,15337
 dodal/devices/eiger_odin.py,sha256=oZl16K-Qb2yL6tK1fyDQvqbbhhvYMSVcf_e2CjlqMa4,7409
 dodal/devices/fast_grid_scan.py,sha256=DfO4w8ivQJACurYO_OEoXYTAMa2qUc5P-bxYCkjRKkQ,11967
 dodal/devices/fluorescence_detector_motion.py,sha256=-1qCSvW0PdT0m6BcoLxrtc0OJ5UDIBsEe11EOLr-gFw,501
@@ -136,12 +136,17 @@ dodal/devices/zocalo/zocalo_constants.py,sha256=vu7Xjz7UNEpBUWEEBxDvP4bVFkZIN6NL
 dodal/devices/zocalo/zocalo_interaction.py,sha256=8V9rAHYgdrFlPURnsxl5pLheEZemsm8cqMpv0E2fOS8,3555
 dodal/devices/zocalo/zocalo_results.py,sha256=DJWCWKUhMXguUcjb2fU8a86OLp8SnJS9jqbe6EHau-8,15293
 dodal/parameters/experiment_parameter_base.py,sha256=O7JamfuJ5cYHkPf9tsHJPqn-OMHTAGouigvM1cDFehE,313
-dodal/plans/check_topup.py,sha256=3gyLHfHNQBCgEWuAg4QE-ONx7y2Do1vVv5HP8ss0Z1I,5371
-dodal/plans/data_session_metadata.py,sha256=GjR4E2s3ZwYkvkBnW6TcL6OLdmyxrmkoSSI242sEPFA,1567
-dodal/plans/motor_util_plans.py,sha256=1s02s_Yn7vusv8o64n5p4yiibmQ5ETv8t59CD27h8gw,4655
-dls_dodal-1.35.0.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-dls_dodal-1.35.0.dist-info/METADATA,sha256=Ddaa6HHHR3d-IxRoiQS_uiniR2ONfL62B2LVy8b46ns,16574
-dls_dodal-1.35.0.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
-dls_dodal-1.35.0.dist-info/entry_points.txt,sha256=bycw_EKUzup_rxfCetOwcauXV4kLln_OPpPT8jEnr-I,94
-dls_dodal-1.35.0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
-dls_dodal-1.35.0.dist-info/RECORD,,
+dodal/plan_stubs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dodal/plan_stubs/check_topup.py,sha256=3gyLHfHNQBCgEWuAg4QE-ONx7y2Do1vVv5HP8ss0Z1I,5371
+dodal/plan_stubs/data_session.py,sha256=33wPwbs0mtMnle0H76mH_RNTc5omld7gNSJ9BvRdUnM,1570
+dodal/plan_stubs/motor_utils.py,sha256=4c93U_WgjfmX12uNiztVW2oKxGVWa_SKQdJYCUNmsGU,4653
+dodal/plan_stubs/wrapped.py,sha256=nriHKX4BF010CmrhdoUhY3-txClW5W8TPLz64kE_AXU,4533
+dodal/plans/__init__.py,sha256=nH1jNxw3DzDMg9O8Uda0kqKIalRVEWBrq07OLY6Ey38,93
+dodal/plans/scanspec.py,sha256=Q0AcvTKRT401iGMRDSqK-D523UX5_ofiVMZ_rNXKOx8,2074
+dodal/plans/wrapped.py,sha256=Cr2iOpQCuk2ORKo5CZOh-zbQXAjoTfaLrfm7r1--GhU,2098
+dls_dodal-1.36.0.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+dls_dodal-1.36.0.dist-info/METADATA,sha256=93qlfEkDtkITxpzgYXuicmGrR30ilk3Te0IcOalpaSs,16655
+dls_dodal-1.36.0.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+dls_dodal-1.36.0.dist-info/entry_points.txt,sha256=bycw_EKUzup_rxfCetOwcauXV4kLln_OPpPT8jEnr-I,94
+dls_dodal-1.36.0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
+dls_dodal-1.36.0.dist-info/RECORD,,

{dls_dodal-1.35.0.dist-info → dls_dodal-1.36.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.4.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dodal/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.35.0'
-__version_tuple__ = version_tuple = (1, 35, 0)
+__version__ = version = '1.36.0'
+__version_tuple__ = version_tuple = (1, 36, 0)

dodal/devices/eiger.py

@@ -1,4 +1,5 @@
 # type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
+from dataclasses import dataclass
 from enum import Enum
 
 from ophyd import Component, Device, EpicsSignalRO, Signal
@@ -14,6 +15,15 @@ from dodal.log import LOGGER
 FREE_RUN_MAX_IMAGES = 1000000
 
 
+@dataclass
+class EigerTimeouts:
+    stale_params_timeout: int = 60
+    general_status_timeout: int = 10
+    meta_file_ready_timeout: int = 30
+    all_frames_timeout: int = 120
+    arming_timeout: int = 60
+
+
 class InternalEigerTriggerMode(Enum):
     INTERNAL_SERIES = 0
     INTERNAL_ENABLE = 1
@@ -21,6 +31,17 @@ class InternalEigerTriggerMode(Enum):
     EXTERNAL_ENABLE = 3
 
 
+AVAILABLE_TIMEOUTS = {
+    "i03": EigerTimeouts(
+        stale_params_timeout=60,
+        general_status_timeout=10,
+        meta_file_ready_timeout=30,
+        all_frames_timeout=120,  # Long timeout for meta file to compensate for filesystem issues
+        arming_timeout=60,
+    )
+}
+
+
 class EigerDetector(Device):
     class ArmingSignal(Signal):
         def set(self, value, *, timeout=None, settle_time=None, **kwargs):
@@ -34,13 +55,6 @@ class EigerDetector(Device):
     stale_params = Component(EpicsSignalRO, "CAM:StaleParameters_RBV")
     bit_depth = Component(EpicsSignalRO, "CAM:BitDepthImage_RBV")
 
-    STALE_PARAMS_TIMEOUT = 60
-    GENERAL_STATUS_TIMEOUT = 10
-    # Long timeout for meta file to compensate for filesystem issues
-    META_FILE_READY_TIMEOUT = 30
-    ALL_FRAMES_TIMEOUT = 120
-    ARMING_TIMEOUT = 60
-
     filewriters_finished: StatusBase
 
     detector_params: DetectorParams | None = None
@@ -48,13 +62,20 @@ class EigerDetector(Device):
     arming_status = Status()
     arming_status.set_finished()
 
+    def __init__(self, beamline: str = "i03", *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.beamline = beamline
+        # using i03 timeouts as default
+        self.timeouts = AVAILABLE_TIMEOUTS.get(beamline, AVAILABLE_TIMEOUTS["i03"])
+
     @classmethod
     def with_params(
         cls,
         params: DetectorParams,
         name: str = "EigerDetector",
+        beamline: str = "i03",
     ):
-        det = cls(name=name)
+        det = cls(name=name, beamline=beamline)
         det.set_detector_parameters(params)
         return det
 
@@ -82,7 +103,7 @@ class EigerDetector(Device):
     def async_stage(self):
         self.odin.nodes.clear_odin_errors()
         status_ok, error_message = self.odin.wait_for_odin_initialised(
-            self.GENERAL_STATUS_TIMEOUT
+            self.timeouts.general_status_timeout
         )
         if not status_ok:
             raise Exception(f"Odin not initialised: {error_message}")
@@ -96,14 +117,14 @@ class EigerDetector(Device):
     def wait_on_arming_if_started(self):
         if not self.arming_status.done:
             LOGGER.info("Waiting for arming to finish")
-            self.arming_status.wait(self.ARMING_TIMEOUT)
+            self.arming_status.wait(self.timeouts.arming_timeout)
 
     def stage(self):
         self.wait_on_arming_if_started()
         if not self.is_armed():
             LOGGER.info("Eiger not armed, arming")
 
-            self.async_stage().wait(timeout=self.ARMING_TIMEOUT)
+            self.async_stage().wait(timeout=self.timeouts.arming_timeout)
 
     def stop_odin_when_all_frames_collected(self):
         LOGGER.info("Waiting on all frames")
@@ -111,7 +132,7 @@ class EigerDetector(Device):
             await_value(
                 self.odin.file_writer.num_captured,
                 self.detector_params.full_number_of_images,
-            ).wait(self.ALL_FRAMES_TIMEOUT)
+            ).wait(self.timeouts.all_frames_timeout)
         finally:
             LOGGER.info("Stopping Odin")
             self.odin.stop().wait(5)
@@ -124,7 +145,9 @@ class EigerDetector(Device):
                 # In free run mode we have to manually stop odin
                 self.stop_odin_when_all_frames_collected()
 
-            self.odin.file_writer.start_timeout.set(1).wait(self.GENERAL_STATUS_TIMEOUT)
+            self.odin.file_writer.start_timeout.set(1).wait(
+                self.timeouts.general_status_timeout
+            )
             LOGGER.info("Waiting on filewriter to finish")
             self.filewriters_finished.wait(30)
 
@@ -132,7 +155,7 @@ class EigerDetector(Device):
         finally:
             self.disarm_detector()
             status_ok = self.odin.check_and_wait_for_odin_state(
-                self.GENERAL_STATUS_TIMEOUT
+                self.timeouts.general_status_timeout
             )
             self.disable_roi_mode()
         return status_ok
@@ -142,10 +165,12 @@ class EigerDetector(Device):
         LOGGER.info("Eiger stop() called - cleaning up...")
         self.wait_on_arming_if_started()
         stop_status = self.odin.stop()
-        self.odin.file_writer.start_timeout.set(1).wait(self.GENERAL_STATUS_TIMEOUT)
+        self.odin.file_writer.start_timeout.set(1).wait(
+            self.timeouts.general_status_timeout
+        )
         self.disarm_detector()
         stop_status &= self.disable_roi_mode()
-        stop_status.wait(self.GENERAL_STATUS_TIMEOUT)
+        stop_status.wait(self.timeouts.general_status_timeout)
         # See https://github.com/DiamondLightSource/hyperion/issues/1395
         LOGGER.info("Turning off Eiger dev/shm streaming")
         self.odin.fan.dev_shm_enable.set(0).wait()
@@ -166,19 +191,19 @@ class EigerDetector(Device):
         )
 
         status = self.cam.roi_mode.set(
-            1 if enable else 0, timeout=self.GENERAL_STATUS_TIMEOUT
+            1 if enable else 0, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.image_height.set(
-            detector_dimensions.height, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.height, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.image_width.set(
-            detector_dimensions.width, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.width, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.num_row_chunks.set(
-            detector_dimensions.height, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.height, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.num_col_chunks.set(
-            detector_dimensions.width, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.width, timeout=self.timeouts.general_status_timeout
         )
 
         return status
@@ -186,25 +211,29 @@ class EigerDetector(Device):
     def set_cam_pvs(self) -> AndStatus:
         assert self.detector_params is not None
         status = self.cam.acquire_time.set(
-            self.detector_params.exposure_time, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.exposure_time,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.acquire_period.set(
-            self.detector_params.exposure_time, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.exposure_time,
+            timeout=self.timeouts.general_status_timeout,
+        )
+        status &= self.cam.num_exposures.set(
+            1, timeout=self.timeouts.general_status_timeout
         )
-        status &= self.cam.num_exposures.set(1, timeout=self.GENERAL_STATUS_TIMEOUT)
         status &= self.cam.image_mode.set(
-            self.cam.ImageMode.MULTIPLE, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.cam.ImageMode.MULTIPLE, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.trigger_mode.set(
             InternalEigerTriggerMode.EXTERNAL_SERIES.value,
-            timeout=self.GENERAL_STATUS_TIMEOUT,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
     def set_odin_number_of_frame_chunks(self) -> Status:
         assert self.detector_params is not None
         status = self.odin.file_writer.num_frames_chunks.set(
-            1, timeout=self.GENERAL_STATUS_TIMEOUT
+            1, timeout=self.timeouts.general_status_timeout
         )
         return status
 
@@ -212,16 +241,20 @@ class EigerDetector(Device):
         assert self.detector_params is not None
         file_prefix = self.detector_params.full_filename
         status = self.odin.file_writer.file_path.set(
-            self.detector_params.directory, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.directory, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.file_name.set(
-            file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            file_prefix, timeout=self.timeouts.general_status_timeout
         )
         status &= await_value(
-            self.odin.meta.file_name, file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.odin.meta.file_name,
+            file_prefix,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= await_value(
-            self.odin.file_writer.id, file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.odin.file_writer.id,
+            file_prefix,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
@@ -231,19 +264,22 @@ class EigerDetector(Device):
             self.detector_params.detector_distance
         )
         status = self.cam.beam_center_x.set(
-            beam_x_pixels, timeout=self.GENERAL_STATUS_TIMEOUT
+            beam_x_pixels, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.beam_center_y.set(
-            beam_y_pixels, timeout=self.GENERAL_STATUS_TIMEOUT
+            beam_y_pixels, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.det_distance.set(
-            self.detector_params.detector_distance, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.detector_distance,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.omega_start.set(
-            self.detector_params.omega_start, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.omega_start,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.omega_incr.set(
-            self.detector_params.omega_increment, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.omega_increment,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
@@ -259,7 +295,7 @@ class EigerDetector(Device):
         current_energy = self.cam.photon_energy.get()
         if abs(current_energy - energy) > tolerance:
             return self.cam.photon_energy.set(
-                energy, timeout=self.GENERAL_STATUS_TIMEOUT
+                energy, timeout=self.timeouts.general_status_timeout
             )
         else:
             status = Status()
@@ -275,45 +311,46 @@ class EigerDetector(Device):
         assert self.detector_params is not None
         status = self.cam.num_images.set(
             self.detector_params.num_images_per_trigger,
-            timeout=self.GENERAL_STATUS_TIMEOUT,
+            timeout=self.timeouts.general_status_timeout,
         )
         if self.detector_params.trigger_mode == TriggerMode.FREE_RUN:
             # The Eiger can't actually free run so we set a very large number of frames
             status &= self.cam.num_triggers.set(
-                FREE_RUN_MAX_IMAGES, timeout=self.GENERAL_STATUS_TIMEOUT
+                FREE_RUN_MAX_IMAGES, timeout=self.timeouts.general_status_timeout
             )
             # Setting Odin to write 0 frames tells it to write until externally stopped
             status &= self.odin.file_writer.num_capture.set(
-                0, timeout=self.GENERAL_STATUS_TIMEOUT
+                0, timeout=self.timeouts.general_status_timeout
             )
         elif self.detector_params.trigger_mode == TriggerMode.SET_FRAMES:
             status &= self.cam.num_triggers.set(
-                self.detector_params.num_triggers, timeout=self.GENERAL_STATUS_TIMEOUT
+                self.detector_params.num_triggers,
+                timeout=self.timeouts.general_status_timeout,
             )
             status &= self.odin.file_writer.num_capture.set(
                 self.detector_params.full_number_of_images,
-                timeout=self.GENERAL_STATUS_TIMEOUT,
+                timeout=self.timeouts.general_status_timeout,
             )
 
         return status
 
     def _wait_for_odin_status(self) -> StatusBase:
         self.forward_bit_depth_to_filewriter()
-        await_value(self.odin.meta.active, 1).wait(self.GENERAL_STATUS_TIMEOUT)
+        await_value(self.odin.meta.active, 1).wait(self.timeouts.general_status_timeout)
 
         status = self.odin.file_writer.capture.set(
-            1, timeout=self.GENERAL_STATUS_TIMEOUT
+            1, timeout=self.timeouts.general_status_timeout
         )
         LOGGER.info("Eiger staging: awaiting odin metadata")
         status &= await_value(
-            self.odin.meta.ready, 1, timeout=self.META_FILE_READY_TIMEOUT
+            self.odin.meta.ready, 1, timeout=self.timeouts.meta_file_ready_timeout
         )
         return status
 
     def _wait_fan_ready(self) -> StatusBase:
         self.filewriters_finished = self.odin.create_finished_status()
         LOGGER.info("Eiger staging: awaiting odin fan ready")
-        return await_value(self.odin.fan.ready, 1, self.GENERAL_STATUS_TIMEOUT)
+        return await_value(self.odin.fan.ready, 1, self.timeouts.general_status_timeout)
 
     def _finish_arm(self) -> Status:
         LOGGER.info("Eiger staging: Finishing arming")
@@ -324,7 +361,7 @@ class EigerDetector(Device):
     def forward_bit_depth_to_filewriter(self):
         bit_depth = self.bit_depth.get()
         self.odin.file_writer.data_type.set(f"UInt{bit_depth}").wait(
-            self.GENERAL_STATUS_TIMEOUT
+            self.timeouts.general_status_timeout
         )
 
     def change_dev_shm(self, enable_dev_shm: bool):
@@ -332,7 +369,7 @@ class EigerDetector(Device):
         return self.odin.fan.dev_shm_enable.set(1 if enable_dev_shm else 0)
 
     def disarm_detector(self):
-        self.cam.acquire.set(0).wait(self.GENERAL_STATUS_TIMEOUT)
+        self.cam.acquire.set(0).wait(self.timeouts.general_status_timeout)
 
     def do_arming_chain(self) -> Status:
         functions_to_do_arm = []
@@ -355,7 +392,9 @@ class EigerDetector(Device):
             self.set_num_triggers_and_captures,
             lambda: await_value(self.stale_params, 0, 60),
             self._wait_for_odin_status,
-            lambda: self.cam.acquire.set(1, timeout=self.GENERAL_STATUS_TIMEOUT),
+            lambda: self.cam.acquire.set(
+                1, timeout=self.timeouts.general_status_timeout
+            ),
             self._wait_fan_ready,
             self._finish_arm,
         ]

dodal/{plans/data_session_metadata.py → plan_stubs/data_session.py}

@@ -2,7 +2,7 @@ from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import MsgGenerator, make_decorator
 
-from dodal.common.beamlines import beamline_utils
+from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.common.types import UpdatingPathProvider
 
 DATA_SESSION = "data_session"
@@ -31,7 +31,7 @@ def attach_data_session_metadata_wrapper(
         Iterator[Msg]: Plan messages
     """
     if provider is None:
-        provider = beamline_utils.get_path_provider()
+        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()

dodal/{plans/motor_util_plans.py → plan_stubs/motor_utils.py}

@@ -23,7 +23,7 @@ class MoveTooLarge(Exception):
         super().__init__(*args)
 
 
-def _check_and_cache_values(
+def check_and_cache_values(
     devices_and_positions: dict[MovableReadableDevice, float],
     smallest_move: float,
     maximum_move: float,
@@ -89,7 +89,7 @@ def move_and_reset_wrapper(
                                        on. If false it is left up to the caller to wait on
                                        them. Defaults to True.
     """
-    initial_positions = yield from _check_and_cache_values(
+    initial_positions = yield from check_and_cache_values(
         device_and_positions, smallest_move, maximum_move
     )
 

dodal/plan_stubs/wrapped.py

@@ -0,0 +1,150 @@
+import itertools
+from collections.abc import Mapping
+from typing import Annotated, Any
+
+import bluesky.plan_stubs as bps
+from bluesky.protocols import Movable
+from bluesky.utils import MsgGenerator
+
+"""
+Wrappers for Bluesky built-in plan stubs with type hinting
+"""
+
+Group = Annotated[str, "String identifier used by 'wait' or stubs that await"]
+
+
+# After bluesky 1.14, bounds for stubs that move can be narrowed
+# https://github.com/bluesky/bluesky/issues/1821
+def set_absolute(
+    movable: Movable, value: Any, group: Group | None = None, wait: bool = False
+) -> MsgGenerator:
+    """
+    Set a device, wrapper for `bp.abs_set`.
+
+    Args:
+        movable (Movable): The device to set
+        value (T): The new value
+        group (Group | None, optional): The message group to associate with the
+                                           setting, for sequencing. Defaults to None.
+        wait (bool, optional): The group should wait until all setting is complete
+                               (e.g. a motor has finished moving). Defaults to False.
+
+    Returns:
+        MsgGenerator: Plan
+
+    Yields:
+        Iterator[MsgGenerator]: Bluesky messages
+    """
+    return (yield from bps.abs_set(movable, value, group=group, wait=wait))
+
+
+def set_relative(
+    movable: Movable, value: Any, group: Group | None = None, wait: bool = False
+) -> MsgGenerator:
+    """
+    Change a device, wrapper for `bp.rel_set`.
+
+    Args:
+        movable (Movable): The device to set
+        value (T): The new value
+        group (Group | None, optional): The message group to associate with the
+                                           setting, for sequencing. Defaults to None.
+        wait (bool, optional): The group should wait until all setting is complete
+                               (e.g. a motor has finished moving). Defaults to False.
+
+    Returns:
+        MsgGenerator: Plan
+
+    Yields:
+        Iterator[MsgGenerator]: Bluesky messages
+    """
+
+    return (yield from bps.rel_set(movable, value, group=group, wait=wait))
+
+
+def move(moves: Mapping[Movable, Any], group: Group | None = None) -> MsgGenerator:
+    """
+    Move a device, wrapper for `bp.mv`.
+
+    Args:
+        moves (Mapping[Movable, T]): Mapping of Movables to target positions
+        group (Group | None, optional): The message group to associate with the
+                                           setting, for sequencing. Defaults to None.
+
+    Returns:
+        MsgGenerator: Plan
+
+    Yields:
+        Iterator[MsgGenerator]: Bluesky messages
+    """
+
+    return (
+        # type ignore until https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.mv(*itertools.chain.from_iterable(moves.items()), group=group)  # type: ignore
+    )
+
+
+def move_relative(
+    moves: Mapping[Movable, Any], group: Group | None = None
+) -> MsgGenerator:
+    """
+    Move a device relative to its current position, wrapper for `bp.mvr`.
+
+    Args:
+        moves (Mapping[Movable, T]): Mapping of Movables to target deltas
+        group (Group | None, optional): The message group to associate with the
+                                           setting, for sequencing. Defaults to None.
+
+    Returns:
+        MsgGenerator: Plan
+
+    Yields:
+        Iterator[MsgGenerator]: Bluesky messages
+    """
+
+    return (
+        # type ignore until https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.mvr(*itertools.chain.from_iterable(moves.items()), group=group)  # type: ignore
+    )
+
+
+def sleep(time: float) -> MsgGenerator:
+    """
+    Suspend all action for a given time, wrapper for `bp.sleep`
+
+    Args:
+        time (float): Time to wait in seconds
+
+    Returns:
+        MsgGenerator: Plan
+
+    Yields:
+        Iterator[MsgGenerator]: Bluesky messages
+    """
+
+    return (yield from bps.sleep(time))
+
+
+def wait(
+    group: Group | None = None,
+    timeout: float | None = None,
+) -> MsgGenerator:
+    """
+    Wait for a group status to complete, wrapper for `bp.wait`.
+    Does not expose move_on, as when used as a stub will not fail on Timeout.
+
+    Args:
+        group (Group | None, optional): The name of the group to wait for, defaults
+                                           to None, in which case waits for all
+                                           groups that have not yet been awaited.
+        timeout (float | None, default=None): a timeout in seconds
+
+
+    Returns:
+        MsgGenerator: Plan
+
+    Yields:
+        Iterator[MsgGenerator]: Bluesky messages
+    """
+
+    return (yield from bps.wait(group, timeout=timeout))

dodal/plans/__init__.py

@@ -0,0 +1,4 @@
+from .scanspec import spec_scan
+from .wrapped import count
+
+__all__ = ["count", "spec_scan"]

dodal/plans/scanspec.py

@@ -0,0 +1,66 @@
+import operator
+from functools import reduce
+from typing import Annotated, Any
+
+import bluesky.plans as bp
+from bluesky.protocols import Movable, Readable
+from cycler import Cycler, cycler
+from pydantic import Field, validate_call
+from scanspec.specs import Spec
+
+from dodal.common import MsgGenerator
+from dodal.plan_stubs.data_session import attach_data_session_metadata_decorator
+
+
+@attach_data_session_metadata_decorator()
+@validate_call(config={"arbitrary_types_allowed": True})
+def spec_scan(
+    detectors: Annotated[
+        set[Readable],
+        Field(
+            description="Set of readable devices, will take a reading at each point, \
+            in addition to any Movables in the Spec",
+        ),
+    ],
+    spec: Annotated[
+        Spec[Movable],
+        Field(description="ScanSpec modelling the path of the scan"),
+    ],
+    metadata: dict[str, Any] | None = None,
+) -> MsgGenerator:
+    """Generic plan for reading `detectors` at every point of a ScanSpec `Spec`.
+    A `Spec` is an N-dimensional path.
+    """
+    # TODO: https://github.com/bluesky/scanspec/issues/154
+    # support Static.duration: Spec[Literal["DURATION"]]
+
+    _md = {
+        "plan_args": {
+            "detectors": {det.name for det in detectors},
+            "spec": repr(spec),
+        },
+        "plan_name": "spec_scan",
+        "shape": spec.shape(),
+        **(metadata or {}),
+    }
+
+    yield from bp.scan_nd(tuple(detectors), _as_cycler(spec), md=_md)
+
+
+def _as_cycler(spec: Spec[Movable]) -> Cycler:
+    """
+    Convert a scanspec to a cycler for compatibility with legacy Bluesky plans such as
+    `bp.scan_nd`. Use the midpoints of the scanspec since cyclers are normally used
+    for software triggered scans.
+
+    Args:
+        spec: A scanspec
+
+    Returns:
+        Cycler: A new cycler
+    """
+
+    midpoints = spec.frames().midpoints
+    # Need to "add" the cyclers for all the axes together. The code below is
+    # effectively: cycler(motor1, [...]) + cycler(motor2, [...]) + ...
+    return reduce(operator.add, (cycler(*args) for args in midpoints.items()))

dodal/plans/wrapped.py

@@ -0,0 +1,57 @@
+from collections.abc import Sequence
+from typing import Annotated, Any
+
+import bluesky.plans as bp
+from bluesky.protocols import Readable
+from pydantic import Field, NonNegativeFloat, validate_call
+
+from dodal.common import MsgGenerator
+from dodal.plan_stubs.data_session import attach_data_session_metadata_decorator
+
+"""This module wraps plan(s) from bluesky.plans until required handling for them is
+moved into bluesky or better handled in downstream services.
+
+Required decorators are installed on plan import
+https://github.com/DiamondLightSource/blueapi/issues/474
+
+Non-serialisable fields are ignored when they are optional
+https://github.com/DiamondLightSource/blueapi/issues/711
+
+We may also need other adjustments for UI purposes, e.g.
+Forcing uniqueness or orderedness of Readables
+Limits and metadata (e.g. units)
+"""
+
+
+@attach_data_session_metadata_decorator()
+@validate_call(config={"arbitrary_types_allowed": True})
+def count(
+    detectors: Annotated[
+        set[Readable],
+        Field(
+            description="Set of readable devices, will take a reading at each point",
+            min_length=1,
+        ),
+    ],
+    num: Annotated[int, Field(description="Number of frames to collect", ge=1)] = 1,
+    delay: Annotated[
+        NonNegativeFloat | Sequence[NonNegativeFloat],
+        Field(
+            description="Delay between readings: if tuple, len(delay) == num - 1 and \
+            the delays are between each point, if value or None is the delay for every \
+            gap",
+            json_schema_extra={"units": "s"},
+        ),
+    ] = 0.0,
+    metadata: dict[str, Any] | None = None,
+) -> MsgGenerator:
+    """Reads from a number of devices.
+    Wraps bluesky.plans.count(det, num, delay, md=metadata) exposing only serializable
+    parameters and metadata."""
+    if isinstance(delay, Sequence):
+        assert (
+            len(delay) == num - 1
+        ), f"Number of delays given must be {num - 1}: was given {len(delay)}"
+    metadata = metadata or {}
+    metadata["shape"] = (num,)
+    yield from bp.count(tuple(detectors), num, delay=delay, md=metadata)