dls-dodal 1.29.0__py3-none-any.whl → 1.29.3__py3-none-any.whl

{dls_dodal-1.29.0.dist-info → dls_dodal-1.29.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.29.0
+Version: 1.29.3
 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
@@ -242,9 +242,11 @@ Requires-Dist: pytest-asyncio ; extra == 'dev'
 Requires-Dist: pytest-cov ; extra == 'dev'
 Requires-Dist: pytest-random-order ; extra == 'dev'
 Requires-Dist: ruff ; extra == 'dev'
-Requires-Dist: sphinx-autobuild ==2024.2.4 ; extra == 'dev'
+Requires-Dist: sphinx-autobuild ; extra == 'dev'
 Requires-Dist: sphinx-copybutton ; extra == 'dev'
+Requires-Dist: sphinxcontrib-mermaid ; extra == 'dev'
 Requires-Dist: sphinx-design ; extra == 'dev'
+Requires-Dist: sphinx-autodoc-typehints ; extra == 'dev'
 Requires-Dist: tox-direct ; extra == 'dev'
 Requires-Dist: types-requests ; extra == 'dev'
 Requires-Dist: types-mock ; extra == 'dev'

{dls_dodal-1.29.0.dist-info → dls_dodal-1.29.3.dist-info}/RECORD

@@ -1,9 +1,9 @@
 dodal/__init__.py,sha256=y-VRpfiX-Lm5nchB9N0VfMy_6dwFqVxpSn5SiAQql9I,114
 dodal/__main__.py,sha256=kP2S2RPitnOWpNGokjZ1Yq-1umOtp5sNOZk2B3tBPLM,111
-dodal/_version.py,sha256=IpRR4M6LqazbEQMvyYdrRT7AijfNAsCfLKuNjjsDX4s,413
+dodal/_version.py,sha256=MFlkKJKBPRaG5o-APjK5uWe00dvrrzhYEjQcU5M7B2I,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
+dodal/log.py,sha256=dfo1rfYrGG8oIm2HkNxaa_ldVs4vJKtgWSoKe1Z_Xno,8533
 dodal/utils.py,sha256=aH-W94t6NFOoGHZ7awbUKY8_k7qIYDourCFs3MKIjjA,10024
 dodal/beamline_specific_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/beamline_specific_utils/i03.py,sha256=Ixe1anFQl-kwRJubmQx28TIW4Zw8qDxpElNNNapWQHI,396
@@ -13,9 +13,9 @@ dodal/beamlines/i03.py,sha256=J-4GawTxAhrYDQZh87n11L9ehTgObEQ1Lz2PueXCWbc,16892
 dodal/beamlines/i04.py,sha256=JOyNcUnC3wva4no2MHKp6b8gOKAcQXL_c4cBo7oneVs,13034
 dodal/beamlines/i04_1.py,sha256=KDxSUQNhIs_NFiRaLY-Jiory0DeN7Y0ErvGuoTrwCDU,4731
 dodal/beamlines/i20_1.py,sha256=MaPgONHqpoZuBtkiKEzYtViJnKBM2_ekeP4OdbmuXHE,1158
-dodal/beamlines/i22.py,sha256=toBwXJiAFbie_puNJzrV1gSUD1FRO2KT9RastqhPNMw,9836
-dodal/beamlines/i23.py,sha256=iEFkrA4sPQsRLGAmeD263jPMX4u2SF1NK4_KYqnVwow,1402
-dodal/beamlines/i24.py,sha256=LIe8tu_ZJsoeQH7tYRZHSvqQ9C9zBGOXO6rb1DPCYjQ,4595
+dodal/beamlines/i22.py,sha256=3VFdA4Wc7O40-64lwUtUBIN23fH4JVNbLKJ1JLjy9as,9870
+dodal/beamlines/i23.py,sha256=2j5qLoqE_hg9ETHqNkOVu7LLkVB8qalgXeORnVYKN_I,1075
+dodal/beamlines/i24.py,sha256=dCMQGcBZ6ADZ6_rEDFcV2BPHGKBC9iVFvfxewxVts4k,6111
 dodal/beamlines/p38.py,sha256=TC78u4GwEnj6X0r5cnHhqNdBbbDRnh8lY8pEucBZjEU,8006
 dodal/beamlines/p45.py,sha256=TNIkC-SBfj0ayZtlLLXW9xCSi5CzJkO8XpAMIo8fjao,2957
 dodal/common/__init__.py,sha256=ZC4ICKUDB0BDxRaVy8nmqclVmDBne-dPtk6UJsoFq6I,258
@@ -40,32 +40,33 @@ dodal/devices/cryostream.py,sha256=6MU4rXIOL33C-8F3DVfAtv0ZnwiysTtawjkeePd5IrQ,3
 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=qp0jdzhTjkDtaf7ngdPcegcFLlp1EmWUDbU_knCBDpc,13438
+dodal/devices/fast_grid_scan.py,sha256=BEj96j78r60JPPJoOMP-XXG-_9yURFTuu-pp2LcqQmY,12452
 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
+dodal/devices/hutch_shutter.py,sha256=nZ3gRbYIVJsXLlpZMWT4UEYUFFQP1MwMe8Oy304QsqE,3360
 dodal/devices/ipin.py,sha256=OGMXwAE4KDDonZRPFkUmR9Vsk6X4Ox-hEvPT5drP-mQ,208
 dodal/devices/linkam3.py,sha256=TPhiQ1D9i_HIlKHAlfnVfX7H6aPOAeXPEJLdmvwdKWQ,3776
 dodal/devices/logging_ophyd_device.py,sha256=xw4lbyqq5_ehESGterVEfubJsBiJTWvBp5b9k62gSkg,666
-dodal/devices/motors.py,sha256=T0wKGpRKhgduAQj3jE8CGmxy3cWMAFl9_glyjVZwjnA,1473
+dodal/devices/motors.py,sha256=16ID2jFJ35h6ZrFp76nJG_oQg6uDrupgcbvcbmjlc7c,300
 dodal/devices/p45.py,sha256=jzBW2fGRhIbGzSRs5Fgupxro6aqE611n1RTcrTTG-yY,1047
 dodal/devices/qbpm1.py,sha256=OY7-WbdxMiLGUK8Z57ezwqSXbHxoPP-y3GvBgj9kgMA,220
-dodal/devices/robot.py,sha256=RcSqBPMMUpWyP7LoyifatII5GWup-vFYZutniM60m_k,4231
+dodal/devices/robot.py,sha256=5WQ9kF5m8xhHhipBycsycDV0-_2IBNBkcwuSWP-9-1I,4337
 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
 dodal/devices/slits.py,sha256=URru9VN2N19KqeUPDZaBmyKYn0_JJiE0Vko4sZpfsl8,601
-dodal/devices/smargon.py,sha256=ml96h7E1C31qPo8jocAepSouIVXgpIR0vuMF99nZjqM,2964
+dodal/devices/smargon.py,sha256=Ds8QFqK3ljbTxalqkQ6clpArj4u4hu9d4vrt97Fzdf4,4693
 dodal/devices/status.py,sha256=TuUGidZ4Ar-WCRc_sX0wn58DmL6brj1pMr8rNF5Z6VU,1198
 dodal/devices/synchrotron.py,sha256=QtTufJA_fCaBawHougSc7nxwu240oX46_y0P-4qIW8o,1960
 dodal/devices/tetramm.py,sha256=XriN-zBFVnHxhnTbphSPIZcxEbdWBTbw2g_ulUBl4bw,8538
-dodal/devices/thawer.py,sha256=L5OYSdzGvx6dIkGgcTbITAbFAm0OKEVVqYBb4MPstOg,382
+dodal/devices/thawer.py,sha256=hIdZOzCNloY7CtSvdE2gk4vCMMoOtaIA4dPH_k0OwFg,1527
 dodal/devices/turbo_slit.py,sha256=W3ZRIqDhq4iMhr5GcIiWvl2U1GaPtGanqkL7upQOZTY,1132
 dodal/devices/undulator.py,sha256=kn84MQpuBHtQj7H7HeBoAYKXu5buGKvTgs3tf2gdEdw,2074
 dodal/devices/undulator_dcm.py,sha256=TC9fO55r1YIG_88PPbGGtzfjcRJcaoC2ny51JiDOEX4,5199
 dodal/devices/webcam.py,sha256=FXYcxQdOOCRIMAf8jMWlDVAhSEs4ycGCnoODvHb-apM,1554
 dodal/devices/xbpm_feedback.py,sha256=8QHYKHo9ksZo30olbFM-tHpCHcJRFozgHKVJijv3Gck,1986
-dodal/devices/zebra.py,sha256=XE2oEm6kLkXd86ev4dYP8bh3tI9Fesb1SmU61RSMHBA,9082
+dodal/devices/zebra.py,sha256=9Zkq5I3-gcP6qfDBnPEAtFU4QJ-VJyp7cHvB79ZfLHk,9186
 dodal/devices/zebra_controlled_shutter.py,sha256=MqX4KE6w0FliZRDBltswcLCNSsp6vQrD_iBY640IljI,1094
 dodal/devices/areadetector/__init__.py,sha256=8IwLxuZMW0MOJpJp_ZDdlaE20hrtsH_PXWGaKgMiYs4,240
 dodal/devices/areadetector/adaravis.py,sha256=pwbmmnakarjhD59XoyAIXJdakS-nqDG09Xmwq17AVw4,3787
@@ -84,13 +85,13 @@ dodal/devices/i20_1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 dodal/devices/i22/dcm.py,sha256=Kzyd_qFg8KVhRsgfTQVOpghESE8yIOgACKa0Fv9NaZI,6270
 dodal/devices/i22/fswitch.py,sha256=AdYtnkCBuhivyJGZqelg_7sjB2pHN7vl1JTtlO4vHo4,3061
 dodal/devices/i22/nxsas.py,sha256=ky7v9UZ1UQFsm5hI0wD9OXG-fTKFLj2wJjB7wADxKpw,5655
-dodal/devices/i23/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dodal/devices/i23/gonio.py,sha256=cxqD2Kd578c4-K4h2sHdJjoap2gPGC46Qr4SPudHLTs,864
-dodal/devices/i24/I24_detector_motion.py,sha256=bKbb44Qs24oguwJ780N4e5XGNtka_3ZZCGGq6BQu99Y,229
+dodal/devices/i24/I24_detector_motion.py,sha256=Joqr1orgeNvRS7n01bjaO-4Yu4obb8fnKaWHQfjPX14,365
 dodal/devices/i24/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dodal/devices/i24/dual_backlight.py,sha256=5Xkkt4VqS-G1QLDmBJNHs-LNVYJ_aTso_ev8QNDJiis,1367
+dodal/devices/i24/aperture.py,sha256=kKfHli5oKp-j-qZhZoXTRK81SAUNyhpI6VRvtw0SkZA,850
+dodal/devices/i24/beamstop.py,sha256=28hQowTvgN5Zw38tkDh32h2ceyN-2GE8bAaGPvDOt5U,1234
+dodal/devices/i24/dual_backlight.py,sha256=Th-RKr28aFxE8LCT_mdN9KkRIVw0BHLGKkI0ienfRZU,2049
 dodal/devices/i24/i24_vgonio.py,sha256=Igqs7687z6lyhGVeJEDtDmPachYxU48MUH2BF0RpK9Q,461
-dodal/devices/i24/pmac.py,sha256=CdNLzRiOz2jFoZ80WQTdlHiYoDJeQWdqdKDkSKkCEkI,3872
+dodal/devices/i24/pmac.py,sha256=pN54myYvzqPl7iW0Vsp59J1EiV_gtn0xQGwbsKJpiYE,3876
 dodal/devices/oav/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/devices/oav/grid_overlay.py,sha256=FRtjcFd420XY8MEQ9sWedL0i4pK-KUJOSxh2C5zM3PA,5232
 dodal/devices/oav/microns_for_zoom_levels.json,sha256=5PA71RzldFTp0eTUGPmov0MjxHe583mzvfor5f3thXI,1208
@@ -104,7 +105,7 @@ dodal/devices/oav/pin_image_recognition/manual_test.py,sha256=h1Rto6ZDCB3jWhjSy9
 dodal/devices/oav/pin_image_recognition/utils.py,sha256=-7-Zs-331UVTq_AZrfdF-zwZdmMn7eitTkBSqnBrxnk,8620
 dodal/devices/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/devices/util/adjuster_plans.py,sha256=2AYaywQP_LbA2KJ6Op3cok8GoRtj696utrSSDfaJtBY,875
-dodal/devices/util/epics_util.py,sha256=FSiTgBhm4id1nILM3UUD7V3eDjJM4DEMIG_wEwzM8Tk,4441
+dodal/devices/util/epics_util.py,sha256=eQr-ImBnADpBL_6XWr3_q9yuMe55Lu0h3j9L1fG4Jws,4714
 dodal/devices/util/lookup_tables.py,sha256=Up-0BlARt79TIEM76SkDyn9LtTFLxPUcaEPZv6D6bws,2141
 dodal/devices/util/motor_utils.py,sha256=pNY-aUk9LxaIWeDr5rpMS6udiB9j19wcCXkNDLp1uA0,257
 dodal/devices/xspress3/xspress3.py,sha256=29elzI3JtceryKeMWXhcP9nWl0tlSdnTZhltCitet6A,4668
@@ -115,9 +116,9 @@ dodal/devices/zocalo/zocalo_results.py,sha256=U4Vk4OF-eL8w0BR-fbw3k4jyRo6G3Ywaf8
 dodal/parameters/experiment_parameter_base.py,sha256=O7JamfuJ5cYHkPf9tsHJPqn-OMHTAGouigvM1cDFehE,313
 dodal/plans/check_topup.py,sha256=Pj6Eu8fa6nvoW4awrMxvzE_ftpLfYz8bN0QDLRw0Yuk,2989
 dodal/plans/data_session_metadata.py,sha256=QNx9rb1EfGBHb21eFekIi7KjNhC0PL-SVKBCggDuNeg,1650
-dls_dodal-1.29.0.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-dls_dodal-1.29.0.dist-info/METADATA,sha256=ydEXpqy3OYgQ-oGOFOzOFk_D4Xhr9N7zUQfvWp51Evo,16842
-dls_dodal-1.29.0.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-dls_dodal-1.29.0.dist-info/entry_points.txt,sha256=wpzz9FsTiYxI8OBwLKX9V9ResLwThBSmtRMcPwII0FA,46
-dls_dodal-1.29.0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
-dls_dodal-1.29.0.dist-info/RECORD,,
+dls_dodal-1.29.3.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+dls_dodal-1.29.3.dist-info/METADATA,sha256=WmlVBYCSTsRn07vPGXJa_FF8x_djiThku9KSaCay3A8,16942
+dls_dodal-1.29.3.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+dls_dodal-1.29.3.dist-info/entry_points.txt,sha256=wpzz9FsTiYxI8OBwLKX9V9ResLwThBSmtRMcPwII0FA,46
+dls_dodal-1.29.3.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
+dls_dodal-1.29.3.dist-info/RECORD,,

{dls_dodal-1.29.0.dist-info → dls_dodal-1.29.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (70.3.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.29.0'
-__version_tuple__ = version_tuple = (1, 29, 0)
+__version__ = version = '1.29.3'
+__version_tuple__ = version_tuple = (1, 29, 3)

dodal/beamlines/i22.py

@@ -360,6 +360,7 @@ def oav(
             x_pixel_size=(3.45e-3, "mm"),  # Double check this figure
             y_pixel_size=(3.45e-3, "mm"),
             description="AVT Mako G-507B",
+            distance=(-1.0, "m"),
         ),
         directory_provider=get_directory_provider(),
     )

dodal/beamlines/i23.py

@@ -1,6 +1,5 @@
 from dodal.common.beamlines.beamline_utils import device_instantiation
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.i23.gonio import Gonio
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import get_beamline_name, get_hostname, skip_device
@@ -19,17 +18,6 @@ def _is_i23_machine():
     return hostname.startswith("i23-ws") or hostname.startswith("i23-control")
 
 
-def gonio(wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False) -> Gonio:
-    """Get the i23 goniometer device"""
-    return device_instantiation(
-        Gonio,
-        "Gonio",
-        "-MO-GONIO-01:",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-    )
-
-
 @skip_device(lambda: not _is_i23_machine())
 def oav_pin_tip_detection(
     wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False

dodal/beamlines/i24.py

@@ -2,11 +2,15 @@ from dodal.common.beamlines.beamline_utils import BL, device_instantiation
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.devices.detector import DetectorParams
 from dodal.devices.eiger import EigerDetector
+from dodal.devices.hutch_shutter import HutchShutter
+from dodal.devices.i24.aperture import Aperture
+from dodal.devices.i24.beamstop import Beamstop
 from dodal.devices.i24.dual_backlight import DualBacklight
 from dodal.devices.i24.I24_detector_motion import DetectorMotion
 from dodal.devices.i24.i24_vgonio import VGonio
 from dodal.devices.i24.pmac import PMAC
-from dodal.devices.oav.oav_detector import OAV, OAVConfigParams
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.oav_parameters import OAVConfigParams
 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
@@ -21,6 +25,32 @@ set_log_beamline(BL)
 set_utils_beamline(BL)
 
 
+def aperture(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> Aperture:
+    """Get the i24 aperture device, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i24, it will return the existing object.
+    """
+    return device_instantiation(
+        Aperture, "aperture", "-AL-APTR-01:", wait_for_connection, fake_with_ophyd_sim
+    )
+
+
+def beamstop(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> Beamstop:
+    """Get the i24 beamstop device, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i24, it will return the existing object.
+    """
+    return device_instantiation(
+        Beamstop,
+        "beamstop",
+        "-MO-BS-01:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )
+
+
 def backlight(
     wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
 ) -> DualBacklight:
@@ -134,3 +164,19 @@ def zebra(wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False) -
         wait_for_connection,
         fake_with_ophyd_sim,
     )
+
+
+@skip_device(lambda: BL == "s24")
+def shutter(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> HutchShutter:
+    """Get the i24 hutch shutter device, instantiate it if it hasn't already been.
+    If this is called when already instantiated, it will return the existing object.
+    """
+    return device_instantiation(
+        HutchShutter,
+        "shutter",
+        "-PS-SHTR-01:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )

dodal/devices/fast_grid_scan.py

@@ -23,7 +23,6 @@ from ophyd_async.epics.signal import (
 from pydantic import validator
 from pydantic.dataclasses import dataclass
 
-from dodal.devices.motors import XYZLimitBundle
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -112,35 +111,6 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
     def _get_z_axis(cls, z_axis: GridAxis, values: dict[str, Any]) -> GridAxis:
         return GridAxis(values["z2_start"], values["z_step_size"], values["z_steps"])
 
-    def is_valid(self, limits: XYZLimitBundle) -> bool:
-        """
-        Validates scan parameters
-
-        :param limits: The motor limits against which to validate
-                       the parameters
-        :return: True if the scan is valid
-        """
-        x_in_limits = limits.x.is_within(self.x_axis.start) and limits.x.is_within(
-            self.x_axis.end
-        )
-        y_in_limits = limits.y.is_within(self.y_axis.start) and limits.y.is_within(
-            self.y_axis.end
-        )
-
-        first_grid_in_limits = (
-            x_in_limits and y_in_limits and limits.z.is_within(self.z1_start)
-        )
-
-        z_in_limits = limits.z.is_within(self.z_axis.start) and limits.z.is_within(
-            self.z_axis.end
-        )
-
-        second_grid_in_limits = (
-            x_in_limits and z_in_limits and limits.y.is_within(self.y2_start)
-        )
-
-        return first_grid_in_limits and second_grid_in_limits
-
     def get_num_images(self):
         return self.x_steps * self.y_steps + self.x_steps * self.z_steps
 

dodal/devices/hutch_shutter.py

@@ -0,0 +1,93 @@
+from enum import Enum
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    StandardReadable,
+    wait_for_value,
+)
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_w
+
+HUTCH_SAFE_FOR_OPERATIONS = 0  # Hutch is locked and can't be entered
+
+
+class ShutterNotSafeToOperateError(Exception):
+    pass
+
+
+class ShutterDemand(str, Enum):
+    OPEN = "Open"
+    CLOSE = "Close"
+    RESET = "Reset"
+
+
+class ShutterState(str, Enum):
+    FAULT = "Fault"
+    OPEN = "Open"
+    OPENING = "Opening"
+    CLOSED = "Closed"
+    CLOSING = "Closing"
+
+
+class HutchInterlock(StandardReadable):
+    """Device to check the interlock status of the hutch."""
+
+    def __init__(self, bl_prefix: str, name: str = "") -> None:
+        self.status = epics_signal_r(float, bl_prefix + "-PS-IOC-01:M14:LOP")
+        super().__init__(name)
+
+    # TODO replace with read
+    # See https://github.com/DiamondLightSource/dodal/issues/651
+    async def shutter_safe_to_operate(self) -> bool:
+        """If the status value is 0, hutch has been searched and locked and it is safe \
+        to operate the shutter.
+        If the status value is not 0 (usually set to 7), the hutch is open and the \
+        shutter should not be in use.
+        """
+        interlock_state = await self.status.get_value()
+        return interlock_state == HUTCH_SAFE_FOR_OPERATIONS
+
+
+class HutchShutter(StandardReadable, Movable):
+    """Device to operate the hutch shutter.
+
+    When a demand is sent, the device should first check the hutch status \
+    and raise an error if it's not interlocked (searched and locked), meaning it's not \
+    safe to operate the shutter.
+
+    If the requested shutter position is "Open", the shutter control PV should first \
+    go to "Reset" and then move to "Open". This is because before opening the hutch \
+    shutter, the interlock status PV (`-PS-SHTR-01:ILKSTA`) will show as `failed` until \
+    the hutch shutter is reset. This will set the interlock status to `OK`, allowing \
+    for shutter operations. Until this step is done, the hutch shutter can't be opened.
+    The reset is not needed for closing the shutter.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.control = epics_signal_w(ShutterDemand, prefix + "CON")
+        self.status = epics_signal_r(ShutterState, prefix + "STA")
+
+        bl_prefix = prefix.split("-")[0]
+        self.interlock = HutchInterlock(bl_prefix)
+
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, position_demand: ShutterDemand):
+        interlock_state = await self.interlock.shutter_safe_to_operate()
+        if not interlock_state:
+            raise ShutterNotSafeToOperateError(
+                "The hutch has not been locked, not operating shutter."
+            )
+        if position_demand == ShutterDemand.OPEN:
+            await self.control.set(ShutterDemand.RESET, wait=True)
+            await self.control.set(position_demand, wait=True)
+            return await wait_for_value(
+                self.status, match=ShutterState.OPEN, timeout=DEFAULT_TIMEOUT
+            )
+        else:
+            await self.control.set(position_demand, wait=True)
+            return await wait_for_value(
+                self.status, match=ShutterState.CLOSED, timeout=DEFAULT_TIMEOUT
+            )

dodal/devices/i24/I24_detector_motion.py

@@ -1,9 +1,12 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motion import Motor
 
 
-class DetectorMotion(Device):
+class DetectorMotion(StandardReadable):
     """Physical motion for detector travel"""
 
-    y = Cpt(EpicsMotor, "Y")  # Vertical
-    z = Cpt(EpicsMotor, "Z")  # Beam
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.y = Motor(prefix + "Y")  # Vertical
+        self.z = Motor(prefix + "Z")  # Beam
+
+        super().__init__(name)

dodal/devices/i24/aperture.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.signal import epics_signal_rw
+
+
+class AperturePositions(str, Enum):
+    IN = "In"
+    OUT = "Out"
+    ROBOT = "Robot"
+    MANUAL = "Manual Mounting"
+
+
+class Aperture(StandardReadable):
+    """Device to trigger the aperture motor move on I24.
+
+    The aperture positioner has 4 possible positions: In, Out, Robot and Manual.
+
+    When a position is selected, the x motor is moved.
+    The position of the y motor is calibrated at start up and is not changed.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.x = Motor(prefix + "X")
+        self.y = Motor(prefix + "Y")
+
+        self.position = epics_signal_rw(AperturePositions, prefix + "MP:SELECT")
+        super().__init__(name)

dodal/devices/i24/beamstop.py

@@ -0,0 +1,38 @@
+from enum import Enum
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.signal import epics_signal_rw
+
+
+class BeamstopPositions(str, Enum):
+    CHECK_BEAM = "CheckBeam"
+    DATA_COLLECTION = "Data Collection"
+    DATA_COLLECTION_FAR = "Data Collection Far"
+    TRAY_MOUNT = "Tray Mount"
+    ROTATABLE = "Rotatable"
+    ROBOT = "Robot"
+
+
+class Beamstop(StandardReadable):
+    """Device to move the beamstop.
+
+    The positioner moves the x,y,z motors when a position is selected.
+    The additional y_rotation motor is independent of the positioner and can to be moved
+    on its own as needed.
+
+    WARNING. Before moving the y_rotation motor away from 0, it is important to make sure
+    that the backlight is in the "OUT" position to avoid a collision.
+    See also https://github.com/DiamondLightSource/dodal/issues/646.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.x = Motor(prefix + "X")
+        self.y = Motor(prefix + "Y")
+        self.z = Motor(prefix + "Z")
+
+        self.y_rotation = Motor(prefix + "ROTY")
+
+        self.pos_select = epics_signal_rw(BeamstopPositions, prefix + "MP:SELECT")
+
+        super().__init__(name)

dodal/devices/i24/dual_backlight.py

@@ -1,14 +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 BacklightPositioner(Device):
+
+class BacklightPositions(str, Enum):
+    OUT = "Out"
+    IN = "In"
+    LOAD_CHECK = "LoadCheck"
+    OAV2 = "OAV2"
+    DIODE = "Diode"
+
+
+class LEDStatus(str, Enum):
+    OFF = "OFF"
+    ON = "ON"
+
+
+class BacklightPositioner(StandardReadable):
     """Device to control the backlight position."""
 
-    # String description of the backlight position e.g. "In", "OAV2"
-    pos_level = Component(EpicsSignal, "MP:SELECT")
+    def __init__(self, prefix: str, name: str = "") -> None:
+        # Enum description of the backlight position e.g. "In", "OAV2"
+        self.pos_level = epics_signal_rw(BacklightPositions, prefix + "MP:SELECT")
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, position: BacklightPositions):
+        await self.pos_level.set(position, wait=True)
 
 
-class DualBacklight(Device):
+class DualBacklight(StandardReadable):
     """
     Device to trigger the dual backlight on I24.
     This device is made up by two LEDs:
@@ -17,27 +39,23 @@ class DualBacklight(Device):
 
     To set the position for LED1:
         b = DualBacklight(name="backlight)
-        b.pos1.pos_level.set("OAV2")
-
-    To see get the available position values for LED1:
-        b.pos1.alowed_backlight_positions
+        b.backlight_position.set("OAV2")
 
     Note that the two LED are independently switched on and off. When LED1 is
     in "Out" position (switched off), LED2 might still be on.
     """
 
-    OUT = "Out"
-    IN = "In"
-
-    led1 = Component(EpicsSignal, "-DI-LED-01:TOGGLE")
-    pos1 = Component(BacklightPositioner, "-MO-BL-01:")
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.backlight_state = epics_signal_rw(LEDStatus, prefix + "-DI-LED-01:TOGGLE")
+        self.backlight_position = BacklightPositioner(prefix + "-MO-BL-01:", name)
 
-    led2 = Component(EpicsSignal, "-DI-LED-02:TOGGLE")
+        self.frontlight_state = epics_signal_rw(LEDStatus, prefix + "-DI-LED-02:TOGGLE")
+        super().__init__(name)
 
-    def set(self, position: str) -> StatusBase:
-        status = self.pos1.pos_level.set(position)
-        if position == self.OUT:
-            status &= self.led1.set("OFF")
+    @AsyncStatus.wrap
+    async def set(self, position: BacklightPositions):
+        await self.backlight_position.set(position)
+        if position == BacklightPositions.OUT:
+            await self.backlight_state.set(LEDStatus.OFF, wait=True)
         else:
-            status &= self.led1.set("ON")
-        return status
+            await self.backlight_state.set(LEDStatus.ON, wait=True)

dodal/devices/i24/pmac.py

@@ -118,7 +118,7 @@ class PMAC(StandardReadable):
 
         # These next signals are readback values on PVARS which are set by the motion
         # program.
-        self.scanstatus = epics_signal_r(int, "BL24I-MO-STEP-14:signal:P2401")
-        self.counter = epics_signal_r(int, "BL24I-MO-STEP-14:signal:P2402")
+        self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
+        self.counter = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2402")
 
         super().__init__(name)

dodal/devices/motors.py

@@ -1,8 +1,3 @@
-from dataclasses import dataclass
-from typing import List, Tuple
-
-import numpy as np
-from ophyd import EpicsMotor
 from ophyd_async.core import Device
 from ophyd_async.epics.motion import Motor
 
@@ -13,46 +8,3 @@ class XYZPositioner(Device):
         self.y = Motor(prefix + "Y")
         self.z = Motor(prefix + "Z")
         super().__init__(name)
-
-
-@dataclass
-class MotorLimitHelper:
-    """
-    Represents motor limit(s)
-    """
-
-    motor: EpicsMotor
-
-    def is_within(self, position: float) -> bool:
-        """Checks position against limits
-
-        :param position: The position to check
-        :return: True if position is within the limits
-        """
-        low = float(self.motor.low_limit_travel.get())
-        high = float(self.motor.high_limit_travel.get())
-        return low <= position <= high
-
-
-@dataclass
-class XYZLimitBundle:
-    """
-    Holder for limits reflecting an x, y, z bundle
-    """
-
-    x: MotorLimitHelper
-    y: MotorLimitHelper
-    z: MotorLimitHelper
-
-    def position_valid(
-        self, position: np.ndarray | List[float] | Tuple[float, float, float]
-    ):
-        if len(position) != 3:
-            raise ValueError(
-                f"Position valid expects a 3-vector, got {position} instead"
-            )
-        return (
-            self.x.is_within(position[0])
-            & self.y.is_within(position[1])
-            & self.z.is_within(position[2])
-        )

dodal/devices/robot.py

@@ -60,7 +60,8 @@ class BartRobot(StandardReadable, Movable):
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
         self.error_str = epics_signal_r(str, prefix + "PRG_ERR_MSG")
-        self.error_code = epics_signal_r(int, prefix + "PRG_ERR_CODE")
+        # Change error_code to int type when https://github.com/bluesky/ophyd-async/issues/280 released
+        self.error_code = epics_signal_r(float, prefix + "PRG_ERR_CODE")
         super().__init__(name=name)
 
     async def pin_mounted_or_no_pin_found(self):

dodal/devices/smargon.py

@@ -1,14 +1,16 @@
+from collections.abc import Generator
+from dataclasses import dataclass
 from enum import Enum
+from math import isclose
+from typing import Collection, cast
 
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor, EpicsSignal
-from ophyd.epics_motor import MotorBundle
-from ophyd.status import StatusBase
+from bluesky import plan_stubs as bps
+from bluesky.utils import Msg
+from ophyd_async.core import AsyncStatus, Device, StandardReadable, wait_for_value
+from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.signal import epics_signal_r
 
-from dodal.devices.motors import MotorLimitHelper, XYZLimitBundle
-from dodal.devices.status import await_approx_value
 from dodal.devices.util.epics_util import SetWhenEnabled
-from dodal.devices.util.motor_utils import ExtendedEpicsMotor
 
 
 class StubPosition(Enum):
@@ -16,6 +18,13 @@ class StubPosition(Enum):
     RESET_TO_ROBOT_LOAD = 1
 
 
+def approx_equal_to(target, deadband: float = 1e-9):
+    def approx_equal_to_target(value):
+        return isclose(target, value, rel_tol=0, abs_tol=deadband)
+
+    return approx_equal_to_target
+
+
 class StubOffsets(Device):
     """Stub offsets are used to change the internal co-ordinate system of the smargon by
     adding an offset to x, y, z.
@@ -25,23 +34,64 @@ class StubOffsets(Device):
     set them so that the current position is zero or to pre-defined positions.
     """
 
-    parent: "Smargon"
+    def __init__(self, name: str = "", prefix: str = ""):
+        self.center_at_current_position = SetWhenEnabled(prefix=prefix + "CENTER_CS")
+        self.to_robot_load = SetWhenEnabled(prefix=prefix + "SET_STUBS_TO_RL")
+        super().__init__(name)
 
-    center_at_current_position = Cpt(SetWhenEnabled, "CENTER_CS")
-    to_robot_load = Cpt(SetWhenEnabled, "SET_STUBS_TO_RL")
-
-    def set(self, pos: StubPosition) -> StatusBase:
+    @AsyncStatus.wrap
+    async def set(self, pos: StubPosition):
         if pos == StubPosition.CURRENT_AS_CENTER:
-            status = self.center_at_current_position.set(1)
-            status &= await_approx_value(self.parent.x, 0.0, deadband=0.1)
-            status &= await_approx_value(self.parent.y, 0.0, deadband=0.1)
-            status &= await_approx_value(self.parent.z, 0.0, deadband=0.1)
-            return status
+            await self.center_at_current_position.set(1)
+            smargon = cast(Smargon, self.parent)
+            await wait_for_value(
+                smargon.x.user_readback, approx_equal_to(0.0, 0.1), None
+            )
+            await wait_for_value(
+                smargon.y.user_readback, approx_equal_to(0.0, 0.1), None
+            )
+            await wait_for_value(
+                smargon.z.user_readback, approx_equal_to(0.0, 0.1), None
+            )
         else:
-            return self.to_robot_load.set(1)
+            await self.to_robot_load.set(1)
+
+
+@dataclass
+class AxisLimit:
+    """Represents the minimum and maximum allowable values on an axis"""
+
+    min_value: float
+    max_value: float
+
+    def contains(self, pos: float):
+        """Determine if the specified value is within limits.
+
+        Args:
+            pos: the value to check
+
+        Returns:
+            True if the value does not exceed the limits
+        """
+        return self.min_value <= pos <= self.max_value
 
 
-class Smargon(MotorBundle):
+@dataclass
+class XYZLimits:
+    """The limits of the smargon x, y, z axes."""
+
+    x: AxisLimit
+    y: AxisLimit
+    z: AxisLimit
+
+    def position_valid(self, pos: Collection[float]) -> bool:
+        return all(
+            axis_limits.contains(value)
+            for axis_limits, value in zip([self.x, self.y, self.z], pos)
+        )
+
+
+class Smargon(StandardReadable):
     """
     Real motors added to allow stops following pin load (e.g. real_x1.stop() )
     X1 and X2 real motors provide compound chi motion as well as the compound X travel,
@@ -49,35 +99,39 @@ class Smargon(MotorBundle):
     Robot loading can nudge these and lead to errors.
     """
 
-    x = Cpt(ExtendedEpicsMotor, "X")
-    y = Cpt(EpicsMotor, "Y")
-    z = Cpt(EpicsMotor, "Z")
-    chi = Cpt(EpicsMotor, "CHI")
-    phi = Cpt(EpicsMotor, "PHI")
-    omega = Cpt(ExtendedEpicsMotor, "OMEGA")
-
-    real_x1 = Cpt(EpicsMotor, "MOTOR_3")
-    real_x2 = Cpt(EpicsMotor, "MOTOR_4")
-    real_y = Cpt(EpicsMotor, "MOTOR_1")
-    real_z = Cpt(EpicsMotor, "MOTOR_2")
-    real_phi = Cpt(EpicsMotor, "MOTOR_5")
-    real_chi = Cpt(EpicsMotor, "MOTOR_6")
-
-    stub_offsets = Cpt(StubOffsets, "")
-
-    disabled = Cpt(EpicsSignal, "DISABLED")
-
-    def get_xyz_limits(self) -> XYZLimitBundle:
-        """Get the limits for the x, y and z axes.
-
-        Note that these limits may not yet be valid until wait_for_connection is called
-        on this MotorBundle.
+    def __init__(self, prefix: str = "", name: str = ""):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+            self.z = Motor(prefix + "Z")
+            self.chi = Motor(prefix + "CHI")
+            self.phi = Motor(prefix + "PHI")
+            self.omega = Motor(prefix + "OMEGA")
+            self.real_x1 = Motor(prefix + "MOTOR_3")
+            self.real_x2 = Motor(prefix + "MOTOR_4")
+            self.real_y = Motor(prefix + "MOTOR_1")
+            self.real_z = Motor(prefix + "MOTOR_2")
+            self.real_phi = Motor(prefix + "MOTOR_5")
+            self.real_chi = Motor(prefix + "MOTOR_6")
+            self.stub_offsets = StubOffsets(prefix=prefix)
+            self.disabled = epics_signal_r(int, prefix + "DISABLED")
+
+        super().__init__(name)
+
+    def get_xyz_limits(self) -> Generator[Msg, None, XYZLimits]:
+        """Obtain a plan stub that returns the smargon XYZ axis limits
+
+        Yields:
+            Bluesky messages
 
         Returns:
-            XYZLimitBundle: The limits for the underlying motors.
+            the axis limits
         """
-        return XYZLimitBundle(
-            MotorLimitHelper(self.x),
-            MotorLimitHelper(self.y),
-            MotorLimitHelper(self.z),
-        )
+        limits = {}
+        for name, pv in [
+            (attr_name, getattr(self, attr_name)) for attr_name in ["x", "y", "z"]
+        ]:
+            min_value = yield from bps.rd(pv.low_limit_travel)
+            max_value = yield from bps.rd(pv.high_limit_travel)
+            limits[name] = AxisLimit(min_value, max_value)
+        return XYZLimits(**limits)

dodal/devices/thawer.py

@@ -1,15 +1,48 @@
+from asyncio import Task, create_task, sleep
 from enum import Enum
 
-from ophyd_async.core import StandardReadable
+from bluesky.protocols import Stoppable
+from ophyd_async.core import AsyncStatus, Device, SignalRW, StandardReadable
 from ophyd_async.epics.signal import epics_signal_rw
 
 
+class ThawingException(Exception):
+    pass
+
+
 class ThawerStates(str, Enum):
     OFF = "Off"
     ON = "On"
 
 
-class Thawer(StandardReadable):
+class ThawingTimer(Device):
+    def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
+        self._control_signal = control_signal
+        self._thawing_task: Task | None = None
+        super().__init__("thaw_for_time_s")
+
+    @AsyncStatus.wrap
+    async def set(self, time_to_thaw_for: float):
+        await self._control_signal.set(ThawerStates.ON)
+        if self._thawing_task and not self._thawing_task.done():
+            raise ThawingException("Thawing task already in progress")
+        self._thawing_task = create_task(sleep(time_to_thaw_for))
+        try:
+            await self._thawing_task
+        finally:
+            await self._control_signal.set(ThawerStates.OFF)
+
+    async def stop(self):
+        if self._thawing_task:
+            self._thawing_task.cancel()
+
+
+class Thawer(StandardReadable, Stoppable):
     def __init__(self, prefix: str, name: str = "") -> None:
         self.control = epics_signal_rw(ThawerStates, prefix + ":CTRL")
+        self.thaw_for_time_s = ThawingTimer(self.control)
         super().__init__(name)
+
+    async def stop(self):
+        await self.thaw_for_time_s.stop()
+        await self.control.set(ThawerStates.OFF)

dodal/devices/util/epics_util.py

@@ -1,10 +1,14 @@
 from functools import partial
 from typing import Callable
 
-from ophyd import Component, Device, EpicsSignal
+from bluesky.protocols import Movable
+from ophyd import Component, EpicsSignal
+from ophyd import Device as OphydDevice
 from ophyd.status import Status, StatusBase
+from ophyd_async.core import AsyncStatus, wait_for_value
+from ophyd_async.core import Device as OphydAsyncDevice
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
-from dodal.devices.status import await_value
 from dodal.log import LOGGER
 
 
@@ -24,7 +28,7 @@ def epics_signal_put_wait(pv_name: str, wait: float = 3.0) -> Component[EpicsSig
 def run_functions_without_blocking(
     functions_to_chain: list[Callable[[], StatusBase]],
     timeout: float = 60.0,
-    associated_obj: Device | None = None,
+    associated_obj: OphydDevice | None = None,
 ) -> Status:
     """Creates and initiates an asynchronous chaining of functions which return a status
 
@@ -112,16 +116,15 @@ def call_func(func: Callable[[], StatusBase]) -> StatusBase:
     return func()
 
 
-class SetWhenEnabled(Device):
+class SetWhenEnabled(OphydAsyncDevice, Movable):
     """A device that sets the proc field of a PV when it becomes enabled."""
 
-    proc = Component(EpicsSignal, ".PROC")
-    disp = Component(EpicsSignal, ".DISP")
+    def __init__(self, name: str = "", prefix: str = ""):
+        self.proc = epics_signal_rw(int, prefix + ".PROC")
+        self.disp = epics_signal_r(int, prefix + ".DISP")
+        super().__init__(name)
 
-    def set(self, proc: int) -> Status:
-        return run_functions_without_blocking(
-            [
-                lambda: await_value(self.disp, 0),
-                lambda: self.proc.set(proc),
-            ]
-        )
+    @AsyncStatus.wrap
+    async def set(self, value: int):
+        await wait_for_value(self.disp, 0, None)
+        await self.proc.set(value)

dodal/devices/zebra.py

@@ -76,6 +76,10 @@ class RotationDirection(str, Enum):
     POSITIVE = "Positive"
     NEGATIVE = "Negative"
 
+    @property
+    def multiplier(self):
+        return 1 if self == RotationDirection.POSITIVE else -1
+
 
 class ArmDemand(Enum):
     ARM = 1

dodal/log.py

@@ -11,13 +11,19 @@ from typing import Deque, Tuple, TypedDict
 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")
 LOGGER.setLevel(logging.DEBUG)
 
-DEFAULT_FORMATTER = logging.Formatter(
-    "[%(asctime)s] %(name)s %(module)s %(levelname)s: %(message)s"
+DEFAULT_FORMATTER = ColoredFormatterWithDeviceName(
+    fmt=DEFAULT_FORMAT, datefmt=DEFAULT_DATE_FORMAT, log_colors=DEFAULT_LOG_COLORS
 )
 ERROR_LOG_BUFFER_LINES = 20000
 INFO_LOG_DAYS = 30
@@ -247,3 +253,8 @@ def get_graylog_configuration(
         return "localhost", 5555
     else:
         return "graylog-log-target.diamond.ac.uk", graylog_port or DEFAULT_GRAYLOG_PORT
+
+
+class _NoOpFileHandler:
+    def write(*args, **kwargs):
+        pass

dodal/devices/i23/gonio.py

@@ -1,29 +0,0 @@
-from ophyd import Component as Cpt
-from ophyd import EpicsMotor
-from ophyd.epics_motor import MotorBundle
-
-from dodal.devices.motors import MotorLimitHelper, XYZLimitBundle
-
-
-class Gonio(MotorBundle):
-    x = Cpt(EpicsMotor, "X")
-    y = Cpt(EpicsMotor, "Y")
-    z = Cpt(EpicsMotor, "Z")
-    kappa = Cpt(EpicsMotor, "KAPPA")
-    phi = Cpt(EpicsMotor, "PHI")
-    omega = Cpt(EpicsMotor, "OMEGA")
-
-    def get_xyz_limits(self) -> XYZLimitBundle:
-        """Get the limits for the x, y and z axes.
-
-        Note that these limits may not yet be valid until wait_for_connection is called
-        on this MotorBundle.
-
-        Returns:
-            XYZLimitBundle: The limits for the underlying motors.
-        """
-        return XYZLimitBundle(
-            MotorLimitHelper(self.x),
-            MotorLimitHelper(self.y),
-            MotorLimitHelper(self.z),
-        )