dls-dodal 1.26.0__py3-none-any.whl → 1.27.0__py3-none-any.whl

{dls_dodal-1.26.0.dist-info → dls_dodal-1.27.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.26.0
+Version: 1.27.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.26.0.dist-info → dls_dodal-1.27.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 dodal/__init__.py,sha256=y-VRpfiX-Lm5nchB9N0VfMy_6dwFqVxpSn5SiAQql9I,114
 dodal/__main__.py,sha256=kP2S2RPitnOWpNGokjZ1Yq-1umOtp5sNOZk2B3tBPLM,111
-dodal/_version.py,sha256=ZreJF-rILTr9IBCA-InSDMjl6Bdsh4uJHrXyWFkH87M,413
+dodal/_version.py,sha256=XlqTK6aXcDzaFgsrMUHCuU_TY8zt9cjwfCWklVgy2Hg,413
 dodal/adsim.py,sha256=OW2dcS7ciD4Yq9WFw4PN_c5Bwccrmu7R-zr-u6ZCbQM,497
 dodal/cli.py,sha256=z0UBESrNrq6Kq4rttp4uHcwS1fnOnRkKBRDHSriPpGY,2058
 dodal/log.py,sha256=grK5-c-V6UjMERwDqYPdKbc_BpycrNb8hP0uteLOVCY,8296
@@ -9,21 +9,21 @@ dodal/beamline_specific_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 dodal/beamline_specific_utils/i03.py,sha256=Ixe1anFQl-kwRJubmQx28TIW4Zw8qDxpElNNNapWQHI,396
 dodal/beamlines/README.md,sha256=K9MkL_GomxlsoTB7Mz-_dJA5NNSbmCfMiutchGg3C8o,404
 dodal/beamlines/__init__.py,sha256=U0dQYFEUloCdQOs24zyfpPTncJXOO4cDcfHSevVOAw4,2890
-dodal/beamlines/i03.py,sha256=BsqiPR-z1svEm0psbTtmW3FR69xcC7_pJqLc5Z27mSQ,15935
-dodal/beamlines/i04.py,sha256=2sa7qbNnIDK7r7d8-9Y296Fvzl8TzI_z_K2u7EsUQQw,12063
+dodal/beamlines/i03.py,sha256=nOWm9iUYOwqUDAkBXC4UkYmN2GGD1MbTgyCCMO_YXBw,16394
+dodal/beamlines/i04.py,sha256=JOyNcUnC3wva4no2MHKp6b8gOKAcQXL_c4cBo7oneVs,13034
 dodal/beamlines/i04_1.py,sha256=KDxSUQNhIs_NFiRaLY-Jiory0DeN7Y0ErvGuoTrwCDU,4731
 dodal/beamlines/i20_1.py,sha256=XJpey1-XZnCVpjK6-tODRYeBofqV44BL8lK5OSdQgiI,746
 dodal/beamlines/i22.py,sha256=TlXgAuRYM4JS733tyZyLMYDyC7ajwg85_XzYI5qh46U,7574
 dodal/beamlines/i23.py,sha256=iEFkrA4sPQsRLGAmeD263jPMX4u2SF1NK4_KYqnVwow,1402
-dodal/beamlines/i24.py,sha256=87ugX8yAv1gqpwskl4RDjqZPraySeD0TDJylI6zUytQ,4569
+dodal/beamlines/i24.py,sha256=LIe8tu_ZJsoeQH7tYRZHSvqQ9C9zBGOXO6rb1DPCYjQ,4595
 dodal/beamlines/p38.py,sha256=0uRL4GVs1sGobr0BZpDDbtStNJcipT6o4FvoA_OWLaE,7120
 dodal/beamlines/p45.py,sha256=TNIkC-SBfj0ayZtlLLXW9xCSi5CzJkO8XpAMIo8fjao,2957
 dodal/common/__init__.py,sha256=ZC4ICKUDB0BDxRaVy8nmqclVmDBne-dPtk6UJsoFq6I,258
-dodal/common/coordination.py,sha256=psJ-UWNk4w9YUy-1Vc-CpSn9ea_Ugs2pY5wFKA7JBEY,1133
+dodal/common/coordination.py,sha256=OxIjDiO1-9A9KESRPFtzwkvvQlavbgA5RHemlbubBPg,1168
 dodal/common/maths.py,sha256=JRSBhbMzwlicKp1_Bsfu9gA79JJA_Dgq9EpbExFH65M,1829
 dodal/common/types.py,sha256=M0gZs9F7--gREF8VYJn-Y1Mt9mIEgp1aLY3oUpUkSno,546
 dodal/common/udc_directory_provider.py,sha256=zNlt_VgdAlyBtVN7neTHk_0tWBbI4pPUL7q9WQOzXvo,1260
-dodal/common/visit.py,sha256=8q-cee1r59tU_ywsxBvUzRMyP3Mn6zRHbE-pQAzBPVM,7545
+dodal/common/visit.py,sha256=MhrFbLptMG0Wvd2nHubBwQ44qAzoP4Bf4_z_-wO8rh0,6063
 dodal/common/beamlines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/common/beamlines/beamline_parameters.py,sha256=N22dtDLw3Hlo7EUmGxe4qFGcu7OnldwCz_mU7yK2rd0,3577
 dodal/common/beamlines/beamline_utils.py,sha256=AgmH9wpnFQ4DHAA7_Yo0COa2piX2ksFxukFt2_600kA,4488
@@ -32,15 +32,15 @@ dodal/devices/CTAB.py,sha256=_MfL_KH4uDPxq_RuHFEZ9HVXOpUnQb5be3csoz9DdAs,1630
 dodal/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/devices/adsim.py,sha256=dMU0TKIuiODHYFHQOH4_5UvB8iJtaJEtjqaEDGjcU-w,311
 dodal/devices/aperture.py,sha256=0MtTzKMDZ5DVAz0DE0kXI0M76VCp0y9vFsrMggEMpxk,586
-dodal/devices/aperturescatterguard.py,sha256=2T1VKzE3-mb9hocZtHRwRqC4Eh_M_r8lCmiYwU_mndE,9906
+dodal/devices/aperturescatterguard.py,sha256=2JJsEPJGJHrI0ztv1cSaP7H5T6qdzDfUcN-VEQ39B8o,11012
 dodal/devices/attenuator.py,sha256=OD7fElTIMHWk7ZopPqEu29lionm7WwgC0-Kvl8vBIb0,2599
-dodal/devices/backlight.py,sha256=9BJcAg1f1kGRlb7bNzeltSDlpBXcxjcW90f87ewnj5k,562
+dodal/devices/backlight.py,sha256=vsNGZB4C_mVMafllvJlOTghsfv6UqALMKUMLXu3WZ5k,1115
 dodal/devices/beamstop.py,sha256=8L3qhlk-3ZBOp10xK1i8qZqYTGOXX1mVF1MgXoN0dfg,215
 dodal/devices/cryostream.py,sha256=6MU4rXIOL33C-8F3DVfAtv0ZnwiysTtawjkeePd5IrQ,332
 dodal/devices/dcm.py,sha256=vfyGYDzfSwTiNqlzkfNjkrL-Q1hNVSgJddvJ5Un_lvg,1610
 dodal/devices/eiger.py,sha256=NE4tHdqgUZpUxJLQbd5lLUIHZcpeotppexJGlDNByzM,13868
 dodal/devices/eiger_odin.py,sha256=U5Byb7uNwDdNscBRp7yBYQrsjKrKXl2l5WdSpL09lAw,6980
-dodal/devices/fast_grid_scan.py,sha256=cbM6Jqcu7Gao0zFH6u8iTuJfojDDYs0AvseAnRs8iMg,12134
+dodal/devices/fast_grid_scan.py,sha256=_jsiUxpMO2rAGDhTFPN8J35e6E0oreLpKYi6W8wQGzs,12798
 dodal/devices/fluorescence_detector_motion.py,sha256=RrXfPmJzWnAjcjp9u0AnJEfjvWPMKburVTySB2hxYbw,181
 dodal/devices/flux.py,sha256=RtPStHw7Mad0igVKntKWVZfuZn2clokVJqH14HLix6M,198
 dodal/devices/focusing_mirror.py,sha256=aRqBkE3OgaXpH6lP3v1VbSYgHsMMbSsPPXzeyAGf_Pg,6435
@@ -50,9 +50,8 @@ dodal/devices/logging_ophyd_device.py,sha256=xw4lbyqq5_ehESGterVEfubJsBiJTWvBp5b
 dodal/devices/lower_gonio_stages.py,sha256=oJ_Xeuqs5E8AWAoZX52jD1qV6pCSjCOjdwnXFKz_xjw,229
 dodal/devices/motors.py,sha256=aKtMv5q_4b1eFhzyuk2-D6zDsY_6cqAmG59y5LWUz1s,1328
 dodal/devices/p45.py,sha256=jzBW2fGRhIbGzSRs5Fgupxro6aqE611n1RTcrTTG-yY,1047
-dodal/devices/panda_fast_grid_scan.py,sha256=cQmrs3pQ3P_J1e5C1IOdjDZibRthIHjqY98eaH5kLCE,5424
 dodal/devices/qbpm1.py,sha256=OY7-WbdxMiLGUK8Z57ezwqSXbHxoPP-y3GvBgj9kgMA,220
-dodal/devices/robot.py,sha256=ITMKXiA83KVCAVI3ZpN-wWCLj62uDmxLBFO3PUheaRg,2379
+dodal/devices/robot.py,sha256=V5Gk-e1ZczU7y8SqU4_1YXYQJ6knoVFtXLZmIDY9MI4,2530
 dodal/devices/s4_slit_gaps.py,sha256=j3kgF9WfGFaU9xdUuiAh-QqI5u_vhiAftaDVINt91SM,243
 dodal/devices/scatterguard.py,sha256=0qnvhoo3RjLsrxVgIoDJpryqunlgMVgaTsoyKRC2g4Y,331
 dodal/devices/scintillator.py,sha256=4Dej1a6HRom9GRwTDsaTKGfvloP20POUqIeHqsI8-R8,184
@@ -61,6 +60,7 @@ dodal/devices/smargon.py,sha256=ml96h7E1C31qPo8jocAepSouIVXgpIR0vuMF99nZjqM,2964
 dodal/devices/status.py,sha256=TuUGidZ4Ar-WCRc_sX0wn58DmL6brj1pMr8rNF5Z6VU,1198
 dodal/devices/synchrotron.py,sha256=E5vcSum-zoD5vIZxa2Xcl0gAkeRqY6a-AfZQICCwLHg,1947
 dodal/devices/tetramm.py,sha256=dHA15KkJhBHwtmbivDua_aVqFbvK47TVQG7KXmn8jQ8,8041
+dodal/devices/thawer.py,sha256=L5OYSdzGvx6dIkGgcTbITAbFAm0OKEVVqYBb4MPstOg,382
 dodal/devices/turbo_slit.py,sha256=W3ZRIqDhq4iMhr5GcIiWvl2U1GaPtGanqkL7upQOZTY,1132
 dodal/devices/undulator.py,sha256=kn84MQpuBHtQj7H7HeBoAYKXu5buGKvTgs3tf2gdEdw,2074
 dodal/devices/undulator_dcm.py,sha256=TC9fO55r1YIG_88PPbGGtzfjcRJcaoC2ny51JiDOEX4,5199
@@ -113,9 +113,10 @@ dodal/devices/zocalo/zocalo_interaction.py,sha256=B6TBTDwUlluksLTwC4TiEEgfFzWLOm
 dodal/devices/zocalo/zocalo_results.py,sha256=U4Vk4OF-eL8w0BR-fbw3k4jyRo6G3Ywaf8NMAkjr4Hs,9658
 dodal/parameters/experiment_parameter_base.py,sha256=O7JamfuJ5cYHkPf9tsHJPqn-OMHTAGouigvM1cDFehE,313
 dodal/plans/check_topup.py,sha256=VOkHak88_r-pdTsSnwAJnbvlK2_UhKnO5I36pJmWKvQ,2985
-dls_dodal-1.26.0.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-dls_dodal-1.26.0.dist-info/METADATA,sha256=0fEtRaibwFzXvFI-JP3xbxw29Sp_H1ocnv23eMgU5xk,16837
-dls_dodal-1.26.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-dls_dodal-1.26.0.dist-info/entry_points.txt,sha256=wpzz9FsTiYxI8OBwLKX9V9ResLwThBSmtRMcPwII0FA,46
-dls_dodal-1.26.0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
-dls_dodal-1.26.0.dist-info/RECORD,,
+dodal/plans/data_session_metadata.py,sha256=QNx9rb1EfGBHb21eFekIi7KjNhC0PL-SVKBCggDuNeg,1650
+dls_dodal-1.27.0.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+dls_dodal-1.27.0.dist-info/METADATA,sha256=mkrOjI4F9mwAZOTOLTSPRfNZu5W1wqlqDo3FOOWn6qs,16837
+dls_dodal-1.27.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+dls_dodal-1.27.0.dist-info/entry_points.txt,sha256=wpzz9FsTiYxI8OBwLKX9V9ResLwThBSmtRMcPwII0FA,46
+dls_dodal-1.27.0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
+dls_dodal-1.27.0.dist-info/RECORD,,

dodal/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.26.0'
-__version_tuple__ = version_tuple = (1, 26, 0)
+__version__ = version = '1.27.0'
+__version_tuple__ = version_tuple = (1, 27, 0)

dodal/beamlines/i03.py

@@ -14,17 +14,17 @@ from dodal.devices.dcm import DCM
 from dodal.devices.detector import DetectorParams
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
-from dodal.devices.fast_grid_scan import FastGridScan
+from dodal.devices.fast_grid_scan import PandAFastGridScan, ZebraFastGridScan
 from dodal.devices.flux import Flux
 from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, VFMMirrorVoltages
 from dodal.devices.oav.oav_detector import OAV, OAVConfigParams
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
-from dodal.devices.panda_fast_grid_scan import PandAFastGridScan
 from dodal.devices.qbpm1 import QBPM1
 from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.thawer import Thawer
 from dodal.devices.undulator import Undulator
 from dodal.devices.undulator_dcm import UndulatorDCM
 from dodal.devices.webcam import Webcam
@@ -199,16 +199,16 @@ def eiger(
     )
 
 
-def fast_grid_scan(
+def zebra_fast_grid_scan(
     wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> FastGridScan:
-    """Get the i03 fast_grid_scan device, instantiate it if it hasn't already been.
+) -> ZebraFastGridScan:
+    """Get the i03 zebra_fast_grid_scan device, instantiate it if it hasn't already been.
     If this is called when already instantiated in i03, it will return the existing object.
     """
     return device_instantiation(
-        device_factory=FastGridScan,
-        name="fast_grid_scan",
-        prefix="-MO-SGON-01:",
+        device_factory=ZebraFastGridScan,
+        name="zebra_fast_grid_scan",
+        prefix="-MO-SGON-01:FGS:",
         wait=wait_for_connection,
         fake=fake_with_ophyd_sim,
     )
@@ -219,7 +219,7 @@ def panda_fast_grid_scan(
 ) -> PandAFastGridScan:
     """Get the i03 panda_fast_grid_scan device, instantiate it if it hasn't already been.
     If this is called when already instantiated in i03, it will return the existing object.
-    This is used instead of the fast_grid_scan device when using the PandA.
+    This is used instead of the zebra_fast_grid_scan device when using the PandA.
     """
     return device_instantiation(
         device_factory=PandAFastGridScan,
@@ -480,3 +480,18 @@ def webcam(
         fake_with_ophyd_sim,
         url="http://i03-webcam1/axis-cgi/jpg/image.cgi",
     )
+
+
+def thawer(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> Thawer:
+    """Get the i03 thawer, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i03, it will return the existing object.
+    """
+    return device_instantiation(
+        Thawer,
+        "thawer",
+        "-EA-THAW-01",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )

dodal/beamlines/i04.py

@@ -8,15 +8,17 @@ from dodal.devices.dcm import DCM
 from dodal.devices.detector import DetectorParams
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
-from dodal.devices.fast_grid_scan import FastGridScan
+from dodal.devices.fast_grid_scan import ZebraFastGridScan
 from dodal.devices.flux import Flux
 from dodal.devices.i04.transfocator import Transfocator
 from dodal.devices.ipin import IPin
 from dodal.devices.motors import XYZPositioner
 from dodal.devices.oav.oav_detector import OAV, OAVConfigParams
+from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.thawer import Thawer
 from dodal.devices.undulator import Undulator
 from dodal.devices.xbpm_feedback import XBPMFeedbackI04
 from dodal.devices.zebra import Zebra
@@ -258,15 +260,15 @@ def eiger(
     )
 
 
-def fast_grid_scan(
+def zebra_fast_grid_scan(
     wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> FastGridScan:
-    """Get the i04 fast_grid_scan device, instantiate it if it hasn't already been.
+) -> ZebraFastGridScan:
+    """Get the i04 zebra_fast_grid_scan device, instantiate it if it hasn't already been.
     If this is called when already instantiated in i04, it will return the existing object.
     """
     return device_instantiation(
-        device_factory=FastGridScan,
-        name="fast_grid_scan",
+        device_factory=ZebraFastGridScan,
+        name="zebra_fast_grid_scan",
         prefix="-MO-SGON-01:",
         wait=wait_for_connection,
         fake=fake_with_ophyd_sim,
@@ -363,3 +365,33 @@ def detector_motion(
         wait=wait_for_connection,
         fake=fake_with_ophyd_sim,
     )
+
+
+def thawer(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> Thawer:
+    """Get the i04 thawer, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i04, it will return the existing object.
+    """
+    return device_instantiation(
+        Thawer,
+        "thawer",
+        "-EA-THAW-01",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )
+
+
+def robot(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> BartRobot:
+    """Get the i04 robot device, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i04, it will return the existing object.
+    """
+    return device_instantiation(
+        BartRobot,
+        "robot",
+        "-MO-ROBOT-01:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )

dodal/beamlines/i24.py

@@ -11,7 +11,9 @@ from dodal.devices.zebra import Zebra
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import get_beamline_name, skip_device
 
-ZOOM_PARAMS_FILE = "/dls_sw/i24/software/gda/config/xml/jCameraManZoomLevels.xml"
+ZOOM_PARAMS_FILE = (
+    "/dls_sw/i24/software/gda_versions/gda_9_34/config/xml/jCameraManZoomLevels.xml"
+)
 DISPLAY_CONFIG = "/dls_sw/i24/software/gda_versions/var/display.configuration"
 
 BL = get_beamline_name("s24")

dodal/common/coordination.py

@@ -1,4 +1,5 @@
 import uuid
+from typing import Any
 
 from dodal.common.types import Group
 
@@ -16,19 +17,20 @@ def group_uuid(name: str) -> Group:
     return f"{name}-{str(uuid.uuid4())[:6]}"
 
 
-def inject(name: str):  # type: ignore
+def inject(name: str) -> Any:  # type: ignore
     """
-    Function to mark a default argument of a plan method as a reference to a device
-    that is stored in the Blueapi context, as devices are constructed on startup of the
-    service, and are not available to be used when writing plans.
-    Bypasses mypy linting, returning x as Any and therefore valid as a default
-    argument.
-    e.g. For a 1-dimensional scan, that is usually performed on a consistent Movable
-    axis with name "stage_x"
+    Function to mark a defaulted argument of a plan as a reference to a device stored
+    in another context and not available to be referenced directly.
+    Bypasses type checking, returning x as Any and therefore valid as a default
+    argument, leaving handling to the context from which the plan is called.
+    Assumes that device.name is unique.
+    e.g. For a 1-dimensional scan, that is usually performed on a Movable with
+    name "stage_x"
+
     def scan(x: Movable = inject("stage_x"), start: float = 0.0 ...)
 
     Args:
-        name (str): Name of a device to be fetched from the Blueapi context
+        name (str): Name of a Device to be fetched from an external context
 
     Returns:
         Any: name but without typing checking, valid as any default type

dodal/common/visit.py

@@ -3,14 +3,10 @@ from pathlib import Path
 from typing import Optional
 
 from aiohttp import ClientSession
-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 pydantic import BaseModel
 
-from dodal.common.beamlines import beamline_utils
-from dodal.common.types import MsgGenerator, UpdatingDirectoryProvider
+from dodal.common.types import UpdatingDirectoryProvider
 from dodal.log import LOGGER
 
 """
@@ -156,41 +152,3 @@ class StaticVisitDirectoryProvider(UpdatingDirectoryProvider):
             raise ValueError(
                 "No current collection, update() needs to be called at least once"
             )
-
-
-DATA_SESSION = "data_session"
-DATA_GROUPS = "data_groups"
-
-
-def attach_metadata(
-    plan: MsgGenerator, provider: UpdatingDirectoryProvider | None
-) -> MsgGenerator:
-    """
-    Attach data session metadata to the runs within a plan and make it correlate
-    with an ophyd-async DirectoryProvider.
-
-    This updates the directory 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.
-
-    Returns:
-        MsgGenerator: A plan
-
-    Yields:
-        Iterator[Msg]: Plan messages
-    """
-    if provider is None:
-        provider = beamline_utils.get_directory_provider()
-    yield from bps.wait_for([provider.update])
-    directory_info: DirectoryInfo = provider()
-    # https://github.com/DiamondLightSource/dodal/issues/452
-    # As part of 452, write each dataCollection into their own folder, then can use resource_dir directly
-    data_session = directory_info.prefix.removesuffix("-")
-    yield from bpp.inject_md_wrapper(plan, md={DATA_SESSION: data_session})
-
-
-attach_metadata_decorator = make_decorator(attach_metadata)

dodal/devices/aperturescatterguard.py

@@ -1,6 +1,7 @@
 import asyncio
 from collections import OrderedDict, namedtuple
 from dataclasses import asdict, dataclass
+from enum import Enum
 
 from bluesky.protocols import Movable, Reading
 from ophyd_async.core import AsyncStatus, SignalR, StandardReadable
@@ -48,8 +49,22 @@ class SingleAperturePosition:
     )
 
 
+# Use StrEnum once we stop python 3.10 support
+class AperturePositionGDANames(str, Enum):
+    LARGE_APERTURE = "LARGE_APERTURE"
+    MEDIUM_APERTURE = "MEDIUM_APERTURE"
+    SMALL_APERTURE = "SMALL_APERTURE"
+    ROBOT_LOAD = "ROBOT_LOAD"
+
+    def __str__(self):
+        return str(self.value)
+
+
 def position_from_params(
-    name: str, GDA_name: str, radius_microns: float | None, params: dict
+    name: str,
+    GDA_name: AperturePositionGDANames,
+    radius_microns: float | None,
+    params: dict,
 ) -> SingleAperturePosition:
     return SingleAperturePosition(
         name,
@@ -77,7 +92,8 @@ def tolerances_from_params(params: dict) -> ApertureScatterguardTolerances:
 
 @dataclass
 class AperturePositions:
-    """Holds the motor positions needed to select a particular aperture size."""
+    """Holds the motor positions needed to select a particular aperture size. This class should be instantiated with definitions for its sizes
+    using from_gda_beamline_params"""
 
     LARGE: SingleAperturePosition
     MEDIUM: SingleAperturePosition
@@ -93,13 +109,32 @@ class AperturePositions:
     @classmethod
     def from_gda_beamline_params(cls, params):
         return cls(
-            LARGE=position_from_params("Large", "LARGE_APERTURE", 100, params),
-            MEDIUM=position_from_params("Medium", "MEDIUM_APERTURE", 50, params),
-            SMALL=position_from_params("Small", "SMALL_APERTURE", 20, params),
-            ROBOT_LOAD=position_from_params("Robot load", "ROBOT_LOAD", None, params),
+            LARGE=position_from_params(
+                "Large", AperturePositionGDANames.LARGE_APERTURE, 100, params
+            ),
+            MEDIUM=position_from_params(
+                "Medium", AperturePositionGDANames.MEDIUM_APERTURE, 50, params
+            ),
+            SMALL=position_from_params(
+                "Small", AperturePositionGDANames.SMALL_APERTURE, 20, params
+            ),
+            ROBOT_LOAD=position_from_params(
+                "Robot load", AperturePositionGDANames.ROBOT_LOAD, None, params
+            ),
             tolerances=tolerances_from_params(params),
         )
 
+    def get_position_from_gda_aperture_name(
+        self, gda_aperture_name: AperturePositionGDANames
+    ) -> SingleAperturePosition:
+        apertures = [ap for ap in self.as_list() if ap.GDA_name == gda_aperture_name]
+        if not apertures:
+            raise ValueError(
+                f"Tried to convert unknown aperture name {gda_aperture_name} to a SingleAperturePosition"
+            )
+        else:
+            return apertures[0]
+
     def as_list(self) -> list[SingleAperturePosition]:
         return [
             self.LARGE,

dodal/devices/backlight.py

@@ -1,20 +1,36 @@
-from ophyd import Component, Device, EpicsSignal, StatusBase
+from enum import Enum
 
+from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.epics.signal import epics_signal_rw
+
+
+class BacklightPower(str, Enum):
+    ON = "On"
+    OFF = "Off"
 
-class Backlight(Device):
-    """Simple device to trigger the pneumatic in/out."""
 
-    OUT = 0
-    IN = 1
+class BacklightPosition(str, Enum):
+    IN = "In"
+    OUT = "Out"
+
+
+class Backlight(StandardReadable):
+    """Simple device to trigger the pneumatic in/out."""
 
-    pos = Component(EpicsSignal, "-EA-BL-01:CTRL")
-    # Toggle to switch it On or Off
-    toggle = Component(EpicsSignal, "-EA-BLIT-01:TOGGLE")
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.power = epics_signal_rw(BacklightPower, prefix + "-EA-BLIT-01:TOGGLE")
+            self.position = epics_signal_rw(
+                BacklightPosition, prefix + "-EA-BL-01:CTRL"
+            )
+        super().__init__(name)
 
-    def set(self, position: int) -> StatusBase:
-        status = self.pos.set(position)
-        if position == self.OUT:
-            status &= self.toggle.set("Off")
+    @AsyncStatus.wrap
+    async def set(self, position: BacklightPosition):
+        """This setter will turn the backlight on when we move it in to the beam and off
+        when we move it out."""
+        await self.position.set(position)
+        if position == BacklightPosition.OUT:
+            await self.power.set(BacklightPower.OFF)
         else:
-            status &= self.toggle.set("On")
-        return status
+            await self.power.set(BacklightPower.ON)

dodal/devices/fast_grid_scan.py

@@ -1,24 +1,27 @@
-import threading
-import time
-from typing import Any
+from abc import ABC
+from typing import Any, Generic, TypeVar
 
 import numpy as np
 from bluesky.plan_stubs import mv
 from numpy import ndarray
-from ophyd import (
-    Component,
+from ophyd_async.core import (
+    AsyncStatus,
     Device,
-    EpicsSignal,
-    EpicsSignalRO,
-    EpicsSignalWithRBV,
     Signal,
+    SignalR,
+    SoftSignalBackend,
+    StandardReadable,
+    wait_for_value,
 )
-from ophyd.status import DeviceStatus, StatusBase
+from ophyd_async.epics.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+)
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
 from pydantic import validator
 from pydantic.dataclasses import dataclass
 
 from dodal.devices.motors import XYZLimitBundle
-from dodal.devices.status import await_value
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -50,9 +53,6 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
     layout to EPICS. The parameters and functions of this class are common
     to both the zebra and panda triggered fast grid scans.
 
-    Motion program will do a grid in x-y then rotate omega +90 and perform
-    a grid in x-z.
-
     The grid specified is where data is taken e.g. it can be assumed the first frame is
     at x_start, y1_start, z1_start and subsequent frames are N*step_size away.
     """
@@ -75,6 +75,21 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
     # Whether to set the stub offsets after centering
     set_stub_offsets: bool = False
 
+    def get_param_positions(self) -> dict:
+        return {
+            "x_steps": self.x_steps,
+            "y_steps": self.y_steps,
+            "z_steps": self.z_steps,
+            "x_step_size": self.x_step_size,
+            "y_step_size": self.y_step_size,
+            "z_step_size": self.z_step_size,
+            "x_start": self.x_start,
+            "y1_start": self.y1_start,
+            "y2_start": self.y2_start,
+            "z1_start": self.z1_start,
+            "z2_start": self.z2_start,
+        }
+
     class Config:
         arbitrary_types_allowed = True
         fields = {
@@ -153,21 +168,21 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
         )
 
 
-class GridScanParams(GridScanParamsCommon):
-    """
-    Holder class for the parameters of a grid scan in a similar
-    layout to EPICS. These params are used for the zebra-triggered
-    fast grid scan
+ParamType = TypeVar("ParamType", bound=GridScanParamsCommon)
 
-    Motion program will do a grid in x-y then rotate omega +90 and perform
-    a grid in x-z.
 
-    The grid specified is where data is taken e.g. it can be assumed the first frame is
-    at x_start, y1_start, z1_start and subsequent frames are N*step_size away.
+class ZebraGridScanParams(GridScanParamsCommon):
+    """
+    Params for standard Zebra FGS. Adds on the dwell time
     """
 
     dwell_time_ms: float = 10
 
+    def get_param_positions(self):
+        param_positions = super().get_param_positions()
+        param_positions["dwell_time_ms"] = self.dwell_time_ms
+        return param_positions
+
     @validator("dwell_time_ms", always=True, check_fields=True)
     def non_integer_dwell_time(cls, dwell_time_ms: float) -> float:
         dwell_time_floor_rounded = np.floor(dwell_time_ms)
@@ -181,181 +196,159 @@ class GridScanParams(GridScanParamsCommon):
         return dwell_time_ms
 
 
-class GridScanCompleteStatus(DeviceStatus):
+class PandAGridScanParams(GridScanParamsCommon):
+    """
+    Params for panda constant-motion scan. Adds on the goniometer run-up distance
+    """
+
+    run_up_distance_mm: float = 0.17
+
+    def get_param_positions(self):
+        param_positions = super().get_param_positions()
+        param_positions["run_up_distance_mm"] = self.run_up_distance_mm
+        return param_positions
+
+
+class MotionProgram(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(name)
+        self.running = epics_signal_r(float, prefix + "PROGBITS")
+        self.program_number = epics_signal_r(float, prefix + "CS1:PROG_NUM")
+
+
+class ExpectedImages(SignalR[int]):
+    def __init__(self, parent: "FastGridScanCommon") -> None:
+        super().__init__(SoftSignalBackend(int))
+        self.parent: "FastGridScanCommon" = parent
+
+    async def get_value(self):
+        x = await self.parent.x_steps.get_value()
+        y = await self.parent.y_steps.get_value()
+        z = await self.parent.z_steps.get_value()
+        first_grid = x * y
+        second_grid = x * z
+        return first_grid + second_grid
+
+
+class FastGridScanCommon(StandardReadable, ABC, Generic[ParamType]):
+    """Device for a general fast grid scan
+
+    When the motion program is started, the goniometer will move in a snake-like grid trajectory,
+    with X as the fast axis and Y as the slow axis. If Z steps isn't 0, the goniometer will
+    then rotate in the omega direction such that it moves from the X-Y, to the X-Z plane then
+    do a second grid scan. The detector is triggered after every x step.
+    See https://github.com/DiamondLightSource/hyperion/wiki/Coordinate-Systems for more
     """
-    A Status for the grid scan completion
-    A special status object that notifies watchers (progress bars)
-    based on comparing device.expected_images to device.position_counter.
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(name)
+        self.x_steps = epics_signal_rw_rbv(int, "X_NUM_STEPS")
+        self.y_steps = epics_signal_rw_rbv(
+            int, "X_NUM_STEPS"
+        )  # Number of vertical steps during the first grid scan
+        self.z_steps = epics_signal_rw_rbv(
+            int, "X_NUM_STEPS"
+        )  # Number of vertical steps during the second grid scan, after the rotation in omega
+        self.x_step_size = epics_signal_rw_rbv(float, "X_STEP_SIZE")
+        self.y_step_size = epics_signal_rw_rbv(float, "Y_STEP_SIZE")
+        self.z_step_size = epics_signal_rw_rbv(float, "Z_STEP_SIZE")
+        self.x_start = epics_signal_rw_rbv(float, "X_START")
+        self.y1_start = epics_signal_rw_rbv(float, "Y_START")
+        self.y2_start = epics_signal_rw_rbv(float, "Y2_START")
+        self.z1_start = epics_signal_rw_rbv(float, "Z_START")
+        self.z2_start = epics_signal_rw_rbv(float, "Z2_START")
+
+        self.position_counter = epics_signal_rw(
+            int, "POS_COUNTER", write_pv="POS_COUNTER_WRITE"
+        )
+        self.x_counter = epics_signal_r(int, "X_COUNTER")
+        self.y_counter = epics_signal_r(int, "Y_COUNTER")
+        self.scan_invalid = epics_signal_r(float, "SCAN_INVALID")
+
+        self.run_cmd = epics_signal_rw(int, "RUN.PROC")
+        self.stop_cmd = epics_signal_rw(int, "STOP.PROC")
+        self.status = epics_signal_r(float, "SCAN_STATUS")
+
+        self.expected_images = ExpectedImages(parent=self)
+
+        self.motion_program = MotionProgram(prefix)
+
+        # Kickoff timeout in seconds
+        self.KICKOFF_TIMEOUT: float = 5.0
+
+        self.COMPLETE_STATUS: float = 60.0
+
+        self.movable_params: dict[str, Signal] = {
+            "x_steps": self.x_steps,
+            "y_steps": self.y_steps,
+            "z_steps": self.z_steps,
+            "x_step_size": self.x_step_size,
+            "y_step_size": self.y_step_size,
+            "z_step_size": self.z_step_size,
+            "x_start": self.x_start,
+            "y1_start": self.y1_start,
+            "y2_start": self.y2_start,
+            "z1_start": self.z1_start,
+            "z2_start": self.z2_start,
+        }
+
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        curr_prog = await self.motion_program.program_number.get_value()
+        running = await self.motion_program.running.get_value()
+        if running:
+            LOGGER.info(f"Motion program {curr_prog} still running, waiting...")
+            await wait_for_value(self.motion_program.running, 0, self.KICKOFF_TIMEOUT)
+
+        LOGGER.debug("Running scan")
+        await self.run_cmd.set(1)
+        LOGGER.info("Waiting for FGS to start")
+        await wait_for_value(self.status, 1, self.KICKOFF_TIMEOUT)
+        LOGGER.debug("FGS kicked off")
+
+    @AsyncStatus.wrap
+    async def complete(self):
+        await wait_for_value(self.status, 0, self.COMPLETE_STATUS)
+
+
+class ZebraFastGridScan(FastGridScanCommon[ZebraGridScanParams]):
+    """Device for standard Zebra FGS. In this scan, the goniometer's velocity profile follows a parabolic shape between X steps,
+    with the slowest points occuring at each X step.
     """
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.start_ts = time.time()
-
-        self.device.position_counter.subscribe(self._notify_watchers)
-        self.device.status.subscribe(self._running_changed)
-
-        self._name = self.device.name
-        self._target_count = self.device.expected_images.get()
-
-    def _notify_watchers(self, value, *args, **kwargs):
-        if not self._watchers:
-            return
-        time_elapsed = time.time() - self.start_ts
-        try:
-            fraction = 1 - value / self._target_count
-        except ZeroDivisionError:
-            fraction = 0
-            time_remaining = 0
-        except Exception as e:
-            fraction = None
-            time_remaining = None
-            self.set_exception(e)
-            self.clean_up()
-        else:
-            time_remaining = time_elapsed / fraction
-        for watcher in self._watchers:
-            watcher(
-                name=self._name,
-                current=value,
-                initial=0,
-                target=self._target_count,
-                unit="images",
-                precision=0,
-                fraction=fraction,
-                time_elapsed=time_elapsed,
-                time_remaining=time_remaining,
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(prefix, name)
+
+        # Time taken to travel between X steps
+        self.dwell_time_ms = epics_signal_rw_rbv(float, "DWELL_TIME")
+        self.movable_params["dwell_time_ms"] = self.dwell_time_ms
+
+
+class PandAFastGridScan(FastGridScanCommon[PandAGridScanParams]):
+    """Device for panda constant-motion scan"""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(prefix, name)
+        self.time_between_x_steps_ms = (
+            epics_signal_rw_rbv(  # Used by motion controller to set goniometer velocity
+                float, "TIME_BETWEEN_X_STEPS"
             )
+        )
 
-    def _running_changed(self, value=None, old_value=None, **kwargs):
-        if (old_value == 1) and (value == 0):
-            self.set_finished()
-            self.clean_up()
+        # Distance before and after the grid given to allow goniometer to reach desired speed while it is within the
+        # grid
+        self.run_up_distance_mm = epics_signal_rw_rbv(float, "RUNUP_DISTANCE")
+        self.movable_params["run_up_distance_mm"] = self.run_up_distance_mm
 
-    def clean_up(self):
-        self.device.position_counter.clear_sub(self._notify_watchers)
-        self.device.status.clear_sub(self._running_changed)
 
+def set_fast_grid_scan_params(scan: FastGridScanCommon[ParamType], params: ParamType):
+    to_move = []
 
-class MotionProgram(Device):
-    running = Component(EpicsSignalRO, "PROGBITS")
-    program_number = Component(EpicsSignalRO, "CS1:PROG_NUM")
-
-
-class FastGridScan(Device):
-    x_steps = Component(EpicsSignalWithRBV, "FGS:X_NUM_STEPS")
-    y_steps = Component(EpicsSignalWithRBV, "FGS:Y_NUM_STEPS")
-    z_steps = Component(EpicsSignalWithRBV, "FGS:Z_NUM_STEPS")
-
-    x_step_size = Component(EpicsSignalWithRBV, "FGS:X_STEP_SIZE")
-    y_step_size = Component(EpicsSignalWithRBV, "FGS:Y_STEP_SIZE")
-    z_step_size = Component(EpicsSignalWithRBV, "FGS:Z_STEP_SIZE")
-
-    dwell_time_ms = Component(EpicsSignalWithRBV, "FGS:DWELL_TIME")
-
-    x_start = Component(EpicsSignalWithRBV, "FGS:X_START")
-    y1_start = Component(EpicsSignalWithRBV, "FGS:Y_START")
-    y2_start = Component(EpicsSignalWithRBV, "FGS:Y2_START")
-    z1_start = Component(EpicsSignalWithRBV, "FGS:Z_START")
-    z2_start = Component(EpicsSignalWithRBV, "FGS:Z2_START")
-
-    position_counter = Component(
-        EpicsSignal, "FGS:POS_COUNTER", write_pv="FGS:POS_COUNTER_WRITE"
-    )
-    x_counter = Component(EpicsSignalRO, "FGS:X_COUNTER")
-    y_counter = Component(EpicsSignalRO, "FGS:Y_COUNTER")
-    scan_invalid = Component(EpicsSignalRO, "FGS:SCAN_INVALID")
-
-    run_cmd = Component(EpicsSignal, "FGS:RUN.PROC")
-    stop_cmd = Component(EpicsSignal, "FGS:STOP.PROC")
-    status = Component(EpicsSignalRO, "FGS:SCAN_STATUS")
-
-    expected_images = Component(Signal)
-
-    motion_program = Component(MotionProgram, "")
-
-    # Kickoff timeout in seconds
-    KICKOFF_TIMEOUT: float = 5.0
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        def set_expected_images(*_, **__):
-            x = int(self.x_steps.get())
-            y = int(self.y_steps.get())
-            z = int(self.z_steps.get())
-            first_grid = x * y
-            second_grid = x * z
-            self.expected_images.put(first_grid + second_grid)
-
-        self.x_steps.subscribe(set_expected_images)
-        self.y_steps.subscribe(set_expected_images)
-        self.z_steps.subscribe(set_expected_images)
-
-    def is_invalid(self) -> bool:
-        if "GONP" in self.scan_invalid.pvname:
-            return False
-        return bool(self.scan_invalid.get())
-
-    def kickoff(self) -> StatusBase:
-        st = DeviceStatus(device=self, timeout=self.KICKOFF_TIMEOUT)
-
-        def scan():
-            try:
-                curr_prog = self.motion_program.program_number.get()
-                running = self.motion_program.running.get()
-                if running:
-                    LOGGER.info(f"Motion program {curr_prog} still running, waiting...")
-                    await_value(self.motion_program.running, 0).wait()
-                LOGGER.debug("Running scan")
-                self.run_cmd.put(1)
-                LOGGER.info("Waiting for FGS to start")
-                await_value(self.status, 1).wait()
-                st.set_finished()
-                LOGGER.debug(f"{st} finished, exiting FGS kickoff thread")
-            except Exception as e:
-                st.set_exception(e)
-
-        threading.Thread(target=scan, daemon=True).start()
-        LOGGER.info("Returning FGS kickoff status")
-        return st
-
-    def complete(self) -> DeviceStatus:
-        return GridScanCompleteStatus(self)
-
-    def collect(self):
-        return {}
-
-    def describe_collect(self):
-        return {}
-
-
-def set_fast_grid_scan_params(scan: FastGridScan, params: GridScanParams):
-    yield from mv(
-        scan.x_steps,
-        params.x_steps,
-        scan.y_steps,
-        params.y_steps,
-        scan.z_steps,
-        params.z_steps,
-        scan.x_step_size,
-        params.x_step_size,
-        scan.y_step_size,
-        params.y_step_size,
-        scan.z_step_size,
-        params.z_step_size,
-        scan.dwell_time_ms,
-        params.dwell_time_ms,
-        scan.x_start,
-        params.x_start,
-        scan.y1_start,
-        params.y1_start,
-        scan.y2_start,
-        params.y2_start,
-        scan.z1_start,
-        params.z1_start,
-        scan.z2_start,
-        params.z2_start,
-        scan.position_counter,
-        0,
-    )
+    # Create arguments for bps.mv
+    for key in scan.movable_params.keys():
+        to_move.extend([scan.movable_params[key], params.__dict__[key]])
+
+    # Counter should always start at 0
+    to_move.extend([scan.position_counter, 0])
+
+    yield from mv(*to_move)

dodal/devices/robot.py

@@ -35,6 +35,8 @@ class BartRobot(StandardReadable, Movable):
         self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
         self.next_pin = epics_signal_rw_rbv(float, prefix + "NEXT_PIN")
         self.next_puck = epics_signal_rw_rbv(float, prefix + "NEXT_PUCK")
+        self.next_sample_id = epics_signal_rw_rbv(float, prefix + "NEXT_ID")
+        self.sample_id = epics_signal_r(float, prefix + "CURRENT_ID_RBV")
         self.load = epics_signal_x(prefix + "LOAD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")

dodal/devices/thawer.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.signal import epics_signal_rw
+
+
+class ThawerStates(str, Enum):
+    OFF = "Off"
+    ON = "On"
+
+
+class Thawer(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.control = epics_signal_rw(ThawerStates, prefix + ":CTRL")
+        super().__init__(name)

dodal/plans/data_session_metadata.py

@@ -0,0 +1,46 @@
+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
+
+DATA_SESSION = "data_session"
+DATA_GROUPS = "data_groups"
+
+
+def attach_data_session_metadata_wrapper(
+    plan: MsgGenerator, provider: UpdatingDirectoryProvider | None = None
+) -> MsgGenerator:
+    """
+    Attach data session metadata to the runs within a plan and make it correlate
+    with an ophyd-async DirectoryProvider.
+
+    This updates the directory 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.
+
+    Returns:
+        MsgGenerator: A plan
+
+    Yields:
+        Iterator[Msg]: Plan messages
+    """
+    if provider is None:
+        provider = beamline_utils.get_directory_provider()
+    yield from bps.wait_for([provider.update])
+    directory_info: DirectoryInfo = provider()
+    # https://github.com/DiamondLightSource/dodal/issues/452
+    # As part of 452, write each dataCollection into their own folder, then can use resource_dir directly
+    data_session = directory_info.prefix.removesuffix("-")
+    yield from bpp.inject_md_wrapper(plan, md={DATA_SESSION: data_session})
+
+
+attach_data_session_metadata_decorator = make_decorator(
+    attach_data_session_metadata_wrapper
+)

dodal/devices/panda_fast_grid_scan.py

@@ -1,162 +0,0 @@
-import threading
-
-from bluesky.plan_stubs import mv
-from ophyd import (
-    Component,
-    Device,
-    EpicsSignal,
-    EpicsSignalRO,
-    EpicsSignalWithRBV,
-    Signal,
-)
-from ophyd.status import DeviceStatus, StatusBase
-
-from dodal.devices.fast_grid_scan import GridScanParamsCommon
-from dodal.devices.status import await_value
-
-
-class GridScanCompleteStatus(DeviceStatus):
-    """
-    A Status for the grid scan completion
-    Progress bar functionality has been removed for now in the panda fast grid scan
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self.device.status.subscribe(self._running_changed)
-
-    def _running_changed(self, value=None, old_value=None, **kwargs):
-        if (old_value == 1) and (value == 0):
-            self.set_finished()
-            self.clean_up()
-
-    def clean_up(self):
-        self.device.status.clear_sub(self._running_changed)
-
-
-class PandAGridScanParams(GridScanParamsCommon):
-    """
-    Holder class for the parameters of a grid scan in a similar
-    layout to EPICS. These params are used for the panda-triggered
-    constant motion grid scan
-
-    Motion program will do a grid in x-y then rotate omega +90 and perform
-    a grid in x-z.
-
-    The grid specified is where data is taken e.g. it can be assumed the first frame is
-    at x_start, y1_start, z1_start and subsequent frames are N*step_size away.
-    """
-
-    run_up_distance_mm: float = 0.17
-
-
-class PandAFastGridScan(Device):
-    """This is similar to the regular FastGridScan device. It has two extra PVs: runup distance and time between x steps.
-    Dwell time is not moved in this scan.
-    """
-
-    x_steps: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "X_NUM_STEPS")
-    y_steps: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "Y_NUM_STEPS")
-    z_steps: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "Z_NUM_STEPS")
-
-    x_step_size: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "X_STEP_SIZE")
-    y_step_size: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "Y_STEP_SIZE")
-    z_step_size: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "Z_STEP_SIZE")
-
-    # This value is fixed by the time between X steps detector deadtime. The only reason it is a PV
-    # Is so the value can be read by the motion program in the PPMAC
-    time_between_x_steps_ms = Component(EpicsSignalWithRBV, "TIME_BETWEEN_X_STEPS")
-
-    run_up_distance: EpicsSignalWithRBV = Component(EpicsSignal, "RUNUP_DISTANCE")
-
-    x_start: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "X_START")
-    y1_start: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "Y_START")
-    y2_start: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "Y2_START")
-    z1_start: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "Z_START")
-    z2_start: EpicsSignalWithRBV = Component(EpicsSignalWithRBV, "Z2_START")
-
-    position_counter: EpicsSignalRO = Component(EpicsSignalRO, "Y_COUNTER")
-    scan_invalid: EpicsSignalRO = Component(EpicsSignalRO, "SCAN_INVALID")
-
-    run_cmd: EpicsSignal = Component(EpicsSignal, "RUN.PROC")
-    stop_cmd: EpicsSignal = Component(EpicsSignal, "STOP.PROC")
-    status: EpicsSignalRO = Component(EpicsSignalRO, "SCAN_STATUS")
-
-    expected_images: Signal = Component(Signal)
-
-    # Kickoff timeout in seconds
-    KICKOFF_TIMEOUT: float = 5.0
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        def set_expected_images(*_, **__):
-            x, y, z = self.x_steps.get(), self.y_steps.get(), self.z_steps.get()
-            first_grid = x * y
-            second_grid = x * z
-            self.expected_images.put(first_grid + second_grid)
-
-        self.x_steps.subscribe(set_expected_images)
-        self.y_steps.subscribe(set_expected_images)
-        self.z_steps.subscribe(set_expected_images)
-
-    def is_invalid(self) -> bool:
-        if "GONP" in self.scan_invalid.pvname:
-            return False
-        return self.scan_invalid.get()
-
-    def kickoff(self) -> StatusBase:
-        # Check running already here?
-        st = DeviceStatus(device=self, timeout=self.KICKOFF_TIMEOUT)
-
-        def scan():
-            try:
-                self.log.debug("Running scan")
-                self.run_cmd.put(1)
-                self.log.debug("Waiting for scan to start")
-                await_value(self.status, 1).wait()
-                st.set_finished()
-            except Exception as e:
-                st.set_exception(e)
-
-        threading.Thread(target=scan, daemon=True).start()
-        return st
-
-    def complete(self) -> DeviceStatus:
-        return GridScanCompleteStatus(self)
-
-    def collect(self):
-        return {}
-
-    def describe_collect(self):
-        return {}
-
-
-def set_fast_grid_scan_params(scan: PandAFastGridScan, params: PandAGridScanParams):
-    yield from mv(
-        scan.x_steps,
-        params.x_steps,
-        scan.y_steps,
-        params.y_steps,
-        scan.z_steps,
-        params.z_steps,
-        scan.x_step_size,
-        params.x_step_size,
-        scan.y_step_size,
-        params.y_step_size,
-        scan.z_step_size,
-        params.z_step_size,
-        scan.x_start,
-        params.x_start,
-        scan.y1_start,
-        params.y1_start,
-        scan.y2_start,
-        params.y2_start,
-        scan.z1_start,
-        params.z1_start,
-        scan.z2_start,
-        params.z2_start,
-        scan.run_up_distance,
-        params.run_up_distance_mm,
-    )