ophyd-async 0.9.0a1__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async-0.10.0a1.dist-info/RECORD

@@ -0,0 +1,149 @@
+ophyd_async/__init__.py,sha256=dcAA3qsj1nNIMe5l-v2tlduZ_ypwBmyuHe45Lsq4k4w,206
+ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
+ophyd_async/_docs_parser.py,sha256=gPYrigfSbYCF7QoSf2UvE-cpQu4snSssl7ZWN-kKDzI,352
+ophyd_async/_version.py,sha256=AdcjN4kVO4q5oA5MXB74BCO4OC6Vbb8sWbQTVnx9yt4,515
+ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/core/__init__.py,sha256=eFRVN5WJQKNcZbFtP8abDcra6d_mwFLA0A60AbXL2Vw,4484
+ophyd_async/core/_derived_signal.py,sha256=UKhqC6RYJ7iAqUvAXwECofm_J4_uyWvTXrikK2Svn0U,10404
+ophyd_async/core/_derived_signal_backend.py,sha256=5_J9AfRPueJZ-CEgpE7GSG9B1nHUFzanD0N2D1mrGrY,12216
+ophyd_async/core/_detector.py,sha256=J5Chu4sI9WgupB_3qh1c7ZOtlv9tSMJ3tXkHnsc9WIw,14517
+ophyd_async/core/_device.py,sha256=UjpKuGvwCYN0-I0qpdWzBI9uLSLieHryDsLf_9Qeu-Y,14593
+ophyd_async/core/_device_filler.py,sha256=MDz8eQQ-eEAwo-UEMxfqPfpcBuMG01tLCGR6utwVnmE,14825
+ophyd_async/core/_flyer.py,sha256=YPCGAokF0GofOOO2OLrsSLoZSXs_RzmmrNglBunA31o,1924
+ophyd_async/core/_hdf_dataset.py,sha256=eKz5wJQrhpnfnnEG9kliFqlEEdaN4oHy98JXsp-tGNE,2956
+ophyd_async/core/_log.py,sha256=DxKR4Nz3SgTaTzKBZWqt-w48yT8WUAr_3Qr223TEWRw,3587
+ophyd_async/core/_mock_signal_backend.py,sha256=SPdCbVWss6-iL9C3t9u0IvR_Ln9JeDypVd18WlivdjE,3156
+ophyd_async/core/_protocol.py,sha256=wQ_snxhTprHqEjQb1HgFwBljwolMY6A8C3xgV1PXwdU,4051
+ophyd_async/core/_providers.py,sha256=VbpRqV9hjv-GV8ngiy52FUoQGnR0XpQ0ZzQ1SPo0NwU,7765
+ophyd_async/core/_readable.py,sha256=o96tsAxOK81554TQtwJobDn6moDimu5u-k-IXfLttO8,11053
+ophyd_async/core/_settings.py,sha256=_ZccbXKP7j5rG6-bMKk7aaLr8hChdRDAPY_YSR71XXM,4213
+ophyd_async/core/_signal.py,sha256=kqIvQXRP3n34-uhgTmbwm2fTIz_phJYyTT4Rm7P-gSs,26412
+ophyd_async/core/_signal_backend.py,sha256=T8vJi-QuMfjB_uBB6iu_aApAY0j5pAFkDn5g2oSCbmI,6826
+ophyd_async/core/_soft_signal_backend.py,sha256=zrE7H2ojHY6oQBucLkFgukszrkdvbIZuavLjEUqc_xM,6227
+ophyd_async/core/_status.py,sha256=h4TtWFM7wFtpxxyAYYSITgcVzArYZdYBHbya6qIX5t0,6553
+ophyd_async/core/_table.py,sha256=46pR9CxNGA5E5-h-vpb2OT5tfaUXfZRSayKhDJHacs4,6888
+ophyd_async/core/_utils.py,sha256=zEA3lLeOP0N17XGUH8irxvEW8hq0slkxY4gJV3f4YzE,11382
+ophyd_async/core/_yaml_settings.py,sha256=txy4_Igbsr8Yo132yv8jnCcsLpal8klM7DcPNow2KBs,2078
+ophyd_async/epics/__init__.py,sha256=ou4yEaH9VZHz70e8oM614-arLMQvUfQyXhRJsnEpWn8,60
+ophyd_async/epics/motor.py,sha256=6AyLQmgqzabcJ4T2yTJBP1omSxxWeya5RbR_r4zYr10,10458
+ophyd_async/epics/signal.py,sha256=0A-supp9ajr63O6aD7F9oG0-Q26YmRjk-ZGh57-jo1Y,239
+ophyd_async/epics/adandor/__init__.py,sha256=qsBoZdljSaqM-kJSvTf0uq5TNwXAih9lP3yOZpKxOFQ,204
+ophyd_async/epics/adandor/_andor.py,sha256=SxAIP9OLefUqKcxrxhjNzil5D8-59Ps0vADdR6scO44,1281
+ophyd_async/epics/adandor/_andor_controller.py,sha256=BqHNo0CqQR9WoxkTYNy0wP0vHKmkQk7PTvEbigLZG6I,1757
+ophyd_async/epics/adandor/_andor_io.py,sha256=L1HmugU6sHK3F_pT0LaN3U1hKlDkzmSwdqr6-LHieTg,1036
+ophyd_async/epics/adaravis/__init__.py,sha256=ZQaJVQiwcQn9hUZADrYgBE1sDfFEwjhVBJRPth1_LBo,395
+ophyd_async/epics/adaravis/_aravis.py,sha256=Ju2wuebz9_ovl-Kza39s5VQ1pV-Omt_BaIWKqP4kcGA,1315
+ophyd_async/epics/adaravis/_aravis_controller.py,sha256=SP3Zpgv8xpOYKJECIrLisQkQMfvfbswHeW5W_mHHhWU,1906
+ophyd_async/epics/adaravis/_aravis_io.py,sha256=af5RxeXF2ligvAXwMNMKHA4QHTR_WmNFz-f18qD2dbg,855
+ophyd_async/epics/adcore/__init__.py,sha256=GipuBZwaAju4g15WjvGs78S4zjGVxmbPel4E29zHFvE,1583
+ophyd_async/epics/adcore/_core_detector.py,sha256=a7S9RViLXd9XnKFWFOhcMrSbubqZoxdQt09BZr8apUQ,2617
+ophyd_async/epics/adcore/_core_io.py,sha256=-MEsDO736idCrAxvT4BnX-NBWLvZGHTNO22c5H09_J8,7406
+ophyd_async/epics/adcore/_core_logic.py,sha256=OPY-yF2lTHDC_KM5AarAfJnvhmmEA63FxKaIRaCCQ_4,8062
+ophyd_async/epics/adcore/_core_writer.py,sha256=D3qOcW8n3FMSLNACpBdCbQG0hmXE3nweTqZNuxoTYME,8207
+ophyd_async/epics/adcore/_hdf_writer.py,sha256=PTciHPAAqsQULncPBXUJ2tS_I232Ko6Hc6IdLHFfKmU,5519
+ophyd_async/epics/adcore/_jpeg_writer.py,sha256=DFv3YdqKjNq0QCb-bLBlxTaGzmHSvdU_rLB29beI46w,748
+ophyd_async/epics/adcore/_single_trigger.py,sha256=tFGLT1b_rZzAvbqWP-hyCccxJMRY26T5IER-VAqKXmc,1275
+ophyd_async/epics/adcore/_tiff_writer.py,sha256=5WXdW0thL9nv2jSMSqF-bMGQjztQZEnx3enY-nGsLiY,749
+ophyd_async/epics/adcore/_utils.py,sha256=wGWpvm2hi-80N-RxbKOO0-GcMf-vs7B9ZDBxpzGd4mA,3952
+ophyd_async/epics/adkinetix/__init__.py,sha256=A9xq3lGMrmza9lfukRixC0Up_kUDVFII8JguLr2x7Bw,308
+ophyd_async/epics/adkinetix/_kinetix.py,sha256=zZv0JZ8i1RSx7KBDn_1HGNOY0BoIP81mRK5TKq7d4eA,1302
+ophyd_async/epics/adkinetix/_kinetix_controller.py,sha256=cL2nf9ntmXDq3BGku9aIUYdm85DdfB7PYhypGuY1PPg,1480
+ophyd_async/epics/adkinetix/_kinetix_io.py,sha256=5u4TknhcoCSjyp16HQIEp_aOmvfNAKOBoGlMRJoVxuw,770
+ophyd_async/epics/adpilatus/__init__.py,sha256=So7PrLHij7LWOqMbsHUhfqRzKp9iKtrojuWTDS1lID8,406
+ophyd_async/epics/adpilatus/_pilatus.py,sha256=SqNjGpZde_9RVSghjx6h9g2SnoJP-EWU4ew3TMXPayc,1511
+ophyd_async/epics/adpilatus/_pilatus_controller.py,sha256=gzGE3eTpsC-CFcNH_g_xQf3M08DcKO3Q0_LnAzKvpFc,2850
+ophyd_async/epics/adpilatus/_pilatus_io.py,sha256=rzH0ciyzIOJUqDe7qdNwG1RhXyQqbJa-4h_88R1vTKc,827
+ophyd_async/epics/adsimdetector/__init__.py,sha256=EQqxP5DUvZGLxpvSXPagTPy3ROwE-PikyRfcnZfD1KM,281
+ophyd_async/epics/adsimdetector/_sim.py,sha256=r3SuBENGkOU-8X-i3zDyZljFxf0SmsUfryNPFvP1_os,1147
+ophyd_async/epics/adsimdetector/_sim_controller.py,sha256=EmoorPTvRomEwfioA9UcrnhYaUBkvtLI2WY3zBLd4ec,476
+ophyd_async/epics/adsimdetector/_sim_io.py,sha256=TOQcawMtb0ypwUlPcbwGfvp5ZI9jceB9OXm53WBF1_o,233
+ophyd_async/epics/advimba/__init__.py,sha256=Onoe4N1DgjUZ0-00krm2-iJPXnNF8nPGs6I8pY9wB1g,429
+ophyd_async/epics/advimba/_vimba.py,sha256=4XlEnsJMGDzHLuYaIDUmaxx0gtOAehn5BKBZMUAzoHQ,1241
+ophyd_async/epics/advimba/_vimba_controller.py,sha256=vv133Eqgk9AI_P5Yy8ZUlry7w-ip56QZ2bPaWenspHo,1979
+ophyd_async/epics/advimba/_vimba_io.py,sha256=cb2Nfp05fBZAcNVXpz-rqRIRS-TiZW5DPUJOmaFyAw0,1589
+ophyd_async/epics/core/__init__.py,sha256=8NoQxEEc2Ny_L9nrD2fnGSf_2gJr1wCR1LwUeLNcIJo,588
+ophyd_async/epics/core/_aioca.py,sha256=HcGYyYUQZmhdUgovf0M9xxL5Ly56ELJDAoRvyRCPq8U,13003
+ophyd_async/epics/core/_epics_connector.py,sha256=S4z_wbj-aogVcjqCyUgjhcq5Y4gDC7y6wXbsSz2nODY,1918
+ophyd_async/epics/core/_epics_device.py,sha256=wGdR24I7GSPh3HmM7jsWKZhBZgt4IyLrCn4Ut7Wx_xo,510
+ophyd_async/epics/core/_p4p.py,sha256=EqelV3Uc7UO7KJ0Bnj5JoISnGVcrm3Hj3v8aTeVbFCo,16398
+ophyd_async/epics/core/_pvi_connector.py,sha256=GSIcul0g6zMEFo_7f6YJCGhekZOm0bJfay_uASw1Hng,5521
+ophyd_async/epics/core/_signal.py,sha256=2Cp5f5Xb2junnVigypjb3hWu4MuMmbrcHOBgPl5Mhv4,5776
+ophyd_async/epics/core/_util.py,sha256=DcfX4VUTeqLrMhVlt1Q7cvBTuYzHePAA-jdR-OWcxMM,2056
+ophyd_async/epics/demo/__init__.py,sha256=WR2M3D8dbHcisJW2OIU2ManZu5SWez8ytZEp4jSBfDY,416
+ophyd_async/epics/demo/__main__.py,sha256=o6M0FSWduPHe2lN9yNEdsXb48NckSd54-XJGoLe20Pc,1116
+ophyd_async/epics/demo/_ioc.py,sha256=UtwTReKTR-1_tPIhdGBr7OxP_Vqi6xWyCcFABd9BYPY,1040
+ophyd_async/epics/demo/_motor.py,sha256=7A-htbAISgB8ZBipouSoSGmpe1wN00VH7H4To16sE4E,3218
+ophyd_async/epics/demo/_point_detector.py,sha256=5m00mBh5knkChnuZD3JNDPaHIGLN0g0toksYm_hpFKo,1398
+ophyd_async/epics/demo/_point_detector_channel.py,sha256=UkidtyaHR_u00lxLb64F7xYhqJowFQQe6kUXKMPHDqE,721
+ophyd_async/epics/demo/_stage.py,sha256=KPnwr5EX8f_0xxkNWT-70a0AqB0D9DoiTbxMmy0iOTo,485
+ophyd_async/epics/demo/motor.db,sha256=3xb6WTXo4crrvk-M8Y16G9pUidp27vD5vIKKBpLTUlk,1017
+ophyd_async/epics/demo/point_detector.db,sha256=8kBa3XKpmfXCxetT4tq5_RFXa_XqS1Z2ZNzsa2AtLds,1366
+ophyd_async/epics/demo/point_detector_channel.db,sha256=FZ9H6HjqplhcF2jgimv_dT1nn-CBlfjs7Y--iCfHp5Y,632
+ophyd_async/epics/eiger/__init__.py,sha256=b3Tt4pVLk23Giyj50R4e94d2MxWDDmNHWhWwNq2jlaw,221
+ophyd_async/epics/eiger/_eiger.py,sha256=YBEGPHFqAwrA6tvNqn9HlPkN0d7GoXlDcT6vjFhhT5Y,1123
+ophyd_async/epics/eiger/_eiger_controller.py,sha256=p_SdYPfSSQvQ3QXZIr7TLOSpPjC-Ce0C7azVOLfZnwY,2544
+ophyd_async/epics/eiger/_eiger_io.py,sha256=AorI8ybAMYQqJZG8QoE3wioPode7fwzRWptNzD5Ynfo,1873
+ophyd_async/epics/eiger/_odin_io.py,sha256=_KdvMEk-c2jrWYflx2a0k5RLDGal-6SVtlGqG10iQA8,4123
+ophyd_async/epics/testing/__init__.py,sha256=aTIv4D2DYrpnGco5RQF8QuLG1SfFkIlTyM2uYEKXltA,522
+ophyd_async/epics/testing/_example_ioc.py,sha256=lGPubU3aXP-8N-Y-6xW1ksRqoawKExFFe1l8zMZqmjk,3864
+ophyd_async/epics/testing/_utils.py,sha256=6sqJ0BCwubSkK-WOJbmpKNqZKG0AmCoevzaMGaRmuJs,1702
+ophyd_async/epics/testing/test_records.db,sha256=hUD9jIzFmN6DgRDGv4-PkeJxCjRjfjvDq5GoTXMz4Zo,3492
+ophyd_async/epics/testing/test_records_pva.db,sha256=HJAJSvLtPWG5B5dKv8OZ0_hPJxRFrDoYp6ROcF2lqyA,4202
+ophyd_async/fastcs/__init__.py,sha256=qlIM9-pjJ8yWfnzTM9-T9cw7zQLKjeeNROQTni5Dr6M,80
+ophyd_async/fastcs/core.py,sha256=pL_srtTrfuoBHUjDFpxES92owFq9M4Jve0Skk1oeuFA,517
+ophyd_async/fastcs/odin/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
+ophyd_async/fastcs/panda/__init__.py,sha256=ugrScVm4HPQFc-d1kTAfZ5UUzW9T3SPgTi0OD2s8ZH0,1003
+ophyd_async/fastcs/panda/_block.py,sha256=YzAxdMsE-kzyz5v47TZHRvCbdbYrSvSrfega53MyX9U,2342
+ophyd_async/fastcs/panda/_control.py,sha256=xtW3dH_MLQoycgP-4vJtYx1M9alHjWo13iu9UFTgwzY,1306
+ophyd_async/fastcs/panda/_hdf_panda.py,sha256=eDxEO5L3tlmPsH06fe2AluXjbGclTpPTj0CnMcVQceU,1277
+ophyd_async/fastcs/panda/_table.py,sha256=maKGoKypEuYqTSVWGgDO6GMEKOtlDm9Dn5YiYdBzu6c,2486
+ophyd_async/fastcs/panda/_trigger.py,sha256=dy4kYdVIU4T90a2bhD7cdnfGrqMxZ_n0AZxkFI5txfA,3388
+ophyd_async/fastcs/panda/_writer.py,sha256=Xh3fNA7wr2tFuqCtnMfAbJT00rziiNypHWDnStGolXg,6143
+ophyd_async/plan_stubs/__init__.py,sha256=2ngpkB4wwqlx1dn9JPSHjQdbyWLmY6n-3XVh3RDE8-g,939
+ophyd_async/plan_stubs/_ensure_connected.py,sha256=YR6VRj7koccJ4x35NV-Ugl4ZbxgAoGN9PjVIjhv0gpw,894
+ophyd_async/plan_stubs/_fly.py,sha256=QdodnmBJ0zrUGxcNY7EzLsiPSD8O3Rq9lE9VrWUX5ik,6233
+ophyd_async/plan_stubs/_nd_attributes.py,sha256=kwzyUSeidUH714gaZQtJLxCgDZtmIRyyoKBBRbvqg38,2350
+ophyd_async/plan_stubs/_panda.py,sha256=5_Mf9kGzNjXpf_YscpCUE8tgq284nOHWCG7o_LNFfII,463
+ophyd_async/plan_stubs/_settings.py,sha256=e3dGVSUV-Htay_9fKXyQTAQLdjunetGI3OBYp_oC_FY,5574
+ophyd_async/plan_stubs/_utils.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
+ophyd_async/plan_stubs/_wait_for_awaitable.py,sha256=PGct_dGezKrLhm0W_GD83dwevSccG_vsmj0WSlMNVWc,364
+ophyd_async/sim/__init__.py,sha256=PzmOQS7suApaZros4h9ec5K6ehFWEjf3qYMvwFGeKsc,749
+ophyd_async/sim/__main__.py,sha256=mx6natJxnvUBTQXbS4R5OGH_MZVgYiXQkoh3JBJ8NxU,1693
+ophyd_async/sim/_blob_detector.py,sha256=4zWsVdn21TM2bHLA-uZRK98t5c2II68fr3Al37apCmc,1082
+ophyd_async/sim/_blob_detector_controller.py,sha256=DBPX3Ig0tS1kzu7uOkFzSdmRjsRP-epA7iMZsggaxhw,1787
+ophyd_async/sim/_blob_detector_writer.py,sha256=ao6RJ9DM_64HoMOp-vR-BaweKwQstLs3E4_MpRzXXZ4,3623
+ophyd_async/sim/_mirror_horizontal.py,sha256=_AfsHxp5V3rYbK-goI0iwPuDDvx1BrNoUQ4smXzqFbc,1452
+ophyd_async/sim/_mirror_vertical.py,sha256=PyWpyCrW_FCzzGN7Dk0tTB-SKbDIV4GD1fl8AXUJbEI,2029
+ophyd_async/sim/_motor.py,sha256=-YMANsq4ZvI7nZolrYaTYe44kMoIcvPKCpBbCeC7pxw,10167
+ophyd_async/sim/_pattern_generator.py,sha256=QU6Hk3TK0TslrDcITTzcB_UDLVIYQ_a8x4nBGJGx_ig,3652
+ophyd_async/sim/_point_detector.py,sha256=nXgL_1aJZciNBw8Zr2wMYaMbzzAEKXV3yV8FQz2nS_4,2940
+ophyd_async/sim/_stage.py,sha256=qaeyZbUVL1v2pTHJiZxq-y6BKpA1l_DAKyzAQppQx70,772
+ophyd_async/tango/__init__.py,sha256=g9xzjlzPpUAP12YI-kYwfAoLSYPAQdL1S11R2c-cius,60
+ophyd_async/tango/core/__init__.py,sha256=IMvQ7MWcTof99h_pr483KWKvQV2-h7zo_iRpLA2PUYQ,1108
+ophyd_async/tango/core/_base_device.py,sha256=mXQnhCzFAdSrynelubhz7iLx_akINJ6s1M08mikFFME,5032
+ophyd_async/tango/core/_converters.py,sha256=auBUdvbsEU8XXNDzX-fiBap0SvvID3ZOAUEP_wjHgBU,2201
+ophyd_async/tango/core/_signal.py,sha256=XZ38hPnThZ-__RDgwH8UfUk78NLcrZ8zVCH8sklr_3U,5798
+ophyd_async/tango/core/_tango_readable.py,sha256=ctR6YcBGGatW6Jp2kvddA1hVZ2v1CidPsF9FmJK9BYg,406
+ophyd_async/tango/core/_tango_transport.py,sha256=FlvadKRW9H_ggcQ3MTiAGHE4HDTKu_rAk5WODMxwk_E,31903
+ophyd_async/tango/core/_utils.py,sha256=FrX524jwa-0EQxpcGaKF6yqyHm5BWIFSE82FcIB0aAY,1430
+ophyd_async/tango/demo/__init__.py,sha256=_j-UicTnckuIBp8PnieFMOMnLFGivnaKdmo9o0hYtzc,256
+ophyd_async/tango/demo/_counter.py,sha256=2J4SCHnBWLF0O5mFWlJdO4tmnElvlx5sRrk4op_AC9U,1139
+ophyd_async/tango/demo/_detector.py,sha256=X5YWHAjukKZ7iYF1fBNle4CBDj1X5rvj0lnPMOcnRCU,1340
+ophyd_async/tango/demo/_mover.py,sha256=c-IxrWQN0YX-Iuf720xlKfsPbNfh7bUz_AVnbwYkW08,2984
+ophyd_async/tango/demo/_tango/__init__.py,sha256=FfONT7vM49nNo3a1Lv-LcMZO9EHv6bv91yY-RnxIib4,85
+ophyd_async/tango/demo/_tango/_servers.py,sha256=nyuKgufKKqtngDeaufbUcHO6byV5MEElf9442ivtUk0,2992
+ophyd_async/tango/testing/__init__.py,sha256=SYXPAS00ny3jlUMOJKpaewO4ljPjK1_z1smj7IfsBQg,148
+ophyd_async/tango/testing/_one_of_everything.py,sha256=rPAgOoNGvaHMVhB79Gz70NI9tWk3QV5iKg5wAlAtqxU,6571
+ophyd_async/testing/__init__.py,sha256=f53HUj2hpIfrza9OlcOpHmq5wnziQNwixawAK4F1xgc,1698
+ophyd_async/testing/__pytest_assert_rewrite.py,sha256=_SU2UfChPgEf7CFY7aYH2B7MLp-07_qYnVLyu6QtDL8,129
+ophyd_async/testing/_assert.py,sha256=sBa2KnNzP01dWDHPKbujIiQk1bw1nTjUyRJKnVPH8Q0,7439
+ophyd_async/testing/_mock_signal_utils.py,sha256=d-n_923ii59-ae9TbqVuIK9MAJpDmu0k47fzgJLj8t8,5195
+ophyd_async/testing/_one_of_everything.py,sha256=Di0hPoKwrDOSsx50-2UdSHM2EbIKrPG9s0Vp11nE9V8,4773
+ophyd_async/testing/_single_derived.py,sha256=icuTFUSaNf_9dZQ37Nt4VHUUERlFdqObhq8S4URdBCo,2694
+ophyd_async/testing/_utils.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
+ophyd_async/testing/_wait_for_pending.py,sha256=YZAR48n-CW0GsPey3zFRzMJ4byDAr3HvMIoawjmTrHw,732
+ophyd_async-0.10.0a1.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.10.0a1.dist-info/METADATA,sha256=8nZ_nv3FefQVDkrlIo6ilDFx8ijbY9tAD6PDvoLAtjE,7075
+ophyd_async-0.10.0a1.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
+ophyd_async-0.10.0a1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.10.0a1.dist-info/RECORD,,

{ophyd_async-0.9.0a1.dist-info → ophyd_async-0.10.0a1.dist-info}/WHEEL

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

ophyd_async/core/_device_save_loader.py

@@ -1,274 +0,0 @@
-from collections.abc import Callable, Generator, Sequence
-from enum import Enum
-from pathlib import Path
-from typing import Any
-
-import numpy as np
-import numpy.typing as npt
-import yaml
-from bluesky.plan_stubs import abs_set, wait
-from bluesky.protocols import Location
-from bluesky.utils import Msg
-from pydantic import BaseModel
-
-from ._device import Device
-from ._signal import SignalRW
-
-
-def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.Node:
-    return dumper.represent_sequence(
-        "tag:yaml.org,2002:seq", array.tolist(), flow_style=True
-    )
-
-
-def pydantic_model_abstraction_representer(
-    dumper: yaml.Dumper, model: BaseModel
-) -> yaml.Node:
-    return dumper.represent_data(model.model_dump(mode="python"))
-
-
-def enum_representer(dumper: yaml.Dumper, enum: Enum) -> yaml.Node:
-    return dumper.represent_data(enum.value)
-
-
-def get_signal_values(
-    signals: dict[str, SignalRW[Any]], ignore: list[str] | None = None
-) -> Generator[Msg, Sequence[Location[Any]], dict[str, Any]]:
-    """Get signal values in bulk.
-
-    Used as part of saving the signals of a device to a yaml file.
-
-    Parameters
-    ----------
-    signals : Dict[str, SignalRW]
-        Dictionary with pv names and matching SignalRW values. Often the direct result
-        of :func:`walk_rw_signals`.
-
-    ignore : Optional[List[str]]
-        Optional list of PVs that should be ignored.
-
-    Returns
-    -------
-    Dict[str, Any]
-        A dictionary containing pv names and their associated values. Ignored pvs are
-        set to None.
-
-    See Also
-    --------
-    :func:`ophyd_async.core.walk_rw_signals`
-    :func:`ophyd_async.core.save_to_yaml`
-    """
-
-    ignore = ignore or []
-    selected_signals = {
-        key: signal for key, signal in signals.items() if key not in ignore
-    }
-    selected_values = yield Msg("locate", *selected_signals.values())
-
-    assert selected_values is not None, "No signalRW's were able to be located"
-    named_values = {
-        key: value["setpoint"]
-        for key, value in zip(selected_signals, selected_values, strict=False)
-    }
-    # Ignored values place in with value None so we know which ones were ignored
-    named_values.update(dict.fromkeys(ignore))
-    return named_values
-
-
-def walk_rw_signals(
-    device: Device, path_prefix: str | None = ""
-) -> dict[str, SignalRW[Any]]:
-    """Retrieve all SignalRWs from a device.
-
-    Stores retrieved signals with their dotted attribute paths in a dictionary. Used as
-    part of saving and loading a device.
-
-    Parameters
-    ----------
-    device : Device
-        Ophyd device to retrieve read-write signals from.
-
-    path_prefix : str
-        For internal use, leave blank when calling the method.
-
-    Returns
-    -------
-    SignalRWs : dict
-        A dictionary matching the string attribute path of a SignalRW with the
-        signal itself.
-
-        See Also
-    --------
-    :func:`ophyd_async.core.get_signal_values`
-    :func:`ophyd_async.core.save_to_yaml`
-
-    """
-
-    if not path_prefix:
-        path_prefix = ""
-
-    signals: dict[str, SignalRW[Any]] = {}
-
-    for attr_name, attr in device.children():
-        dot_path = f"{path_prefix}{attr_name}"
-        if type(attr) is SignalRW:
-            signals[dot_path] = attr
-        attr_signals = walk_rw_signals(attr, path_prefix=dot_path + ".")
-        signals.update(attr_signals)
-    return signals
-
-
-def save_to_yaml(phases: Sequence[dict[str, Any]], save_path: str | Path) -> None:
-    """Plan which serialises a phase or set of phases of SignalRWs to a yaml file.
-
-    Parameters
-    ----------
-    phases : dict or list of dicts
-        The values to save. Each item in the list is a seperate phase used when loading
-        a device. In general this variable be the return value of `get_signal_values`.
-
-    save_path : str
-        Path of the yaml file to write to
-
-    See Also
-    --------
-    :func:`ophyd_async.core.walk_rw_signals`
-    :func:`ophyd_async.core.get_signal_values`
-    :func:`ophyd_async.core.load_from_yaml`
-    """
-
-    yaml.add_representer(np.ndarray, ndarray_representer, Dumper=yaml.Dumper)
-    yaml.add_multi_representer(
-        BaseModel,
-        pydantic_model_abstraction_representer,
-        Dumper=yaml.Dumper,
-    )
-    yaml.add_multi_representer(Enum, enum_representer, Dumper=yaml.Dumper)
-
-    with open(save_path, "w") as file:
-        yaml.dump(phases, file)
-
-
-def load_from_yaml(save_path: str) -> Sequence[dict[str, Any]]:
-    """Plan that returns a list of dicts with saved signal values from a yaml file.
-
-    Parameters
-    ----------
-    save_path : str
-        Path of the yaml file to load from
-
-    See Also
-    --------
-    :func:`ophyd_async.core.save_to_yaml`
-    :func:`ophyd_async.core.set_signal_values`
-    """
-    with open(save_path) as file:
-        return yaml.full_load(file)
-
-
-def set_signal_values(
-    signals: dict[str, SignalRW[Any]], values: Sequence[dict[str, Any]]
-) -> Generator[Msg, None, None]:
-    """Maps signals from a yaml file into device signals.
-
-    ``values`` contains signal values in phases, which are loaded in sequentially
-    into the provided signals, to ensure signals are set in the correct order.
-
-    Parameters
-    ----------
-    signals : Dict[str, SignalRW[Any]]
-        Dictionary of named signals to be updated if value found in values argument.
-        Can be the output of :func:`walk_rw_signals()` for a device.
-
-    values : Sequence[Dict[str, Any]]
-        List of dictionaries of signal name and value pairs, if a signal matches
-        the name of one in the signals argument, sets the signal to that value.
-        The groups of signals are loaded in their list order.
-        Can be the output of :func:`load_from_yaml()` for a yaml file.
-
-    See Also
-    --------
-    :func:`ophyd_async.core.load_from_yaml`
-    :func:`ophyd_async.core.walk_rw_signals`
-    """
-    # For each phase, set all the signals,
-    # load them to the correct value and wait for the load to complete
-    for phase_number, phase in enumerate(values):
-        # Key is signal name
-        for key, value in phase.items():
-            # Skip ignored values
-            if value is None:
-                continue
-
-            if key in signals:
-                yield from abs_set(
-                    signals[key], value, group=f"load-phase{phase_number}"
-                )
-
-        yield from wait(f"load-phase{phase_number}")
-
-
-def load_device(device: Device, path: str):
-    """Plan which loads PVs from a yaml file into a device.
-
-    Parameters
-    ----------
-    device: Device
-        The device to load PVs into
-    path: str
-        Path of the yaml file to load
-
-    See Also
-    --------
-    :func:`ophyd_async.core.save_device`
-    """
-    values = load_from_yaml(path)
-    signals_to_set = walk_rw_signals(device)
-    yield from set_signal_values(signals_to_set, values)
-
-
-def all_at_once(values: dict[str, Any]) -> Sequence[dict[str, Any]]:
-    """Sort all the values into a single phase so they are set all at once"""
-    return [values]
-
-
-def save_device(
-    device: Device,
-    path: str,
-    sorter: Callable[[dict[str, Any]], Sequence[dict[str, Any]]] = all_at_once,
-    ignore: list[str] | None = None,
-):
-    """Plan that saves the state of all PV's on a device using a sorter.
-
-    The default sorter assumes all saved PVs can be loaded at once, and therefore
-    can be saved at one time, i.e. all PVs will appear on one list in the
-    resulting yaml file.
-
-    This can be a problem, because when the yaml is ingested with
-    :func:`ophyd_async.core.load_device`, it will set all of those PVs at once.
-    However, some PV's need to be set before others - this is device specific.
-
-    Therefore, users should consider the order of device loading and write their
-    own sorter algorithms accordingly.
-
-    See :func:`ophyd_async.fastcs.panda.phase_sorter` for a valid implementation of the
-    sorter.
-
-    Parameters
-    ----------
-    device : Device
-        The device whose PVs should be saved.
-
-    path : str
-        The path where the resulting yaml should be saved to
-
-    sorter : Callable[[Dict[str, Any]], Sequence[Dict[str, Any]]]
-
-    ignore : Optional[List[str]]
-
-    See Also
-    --------
-    :func:`ophyd_async.core.load_device`
-    """
-    values = yield from get_signal_values(walk_rw_signals(device), ignore=ignore)
-    save_to_yaml(sorter(values), path)

ophyd_async/epics/demo/_mover.py

@@ -1,95 +0,0 @@
-import asyncio
-
-import numpy as np
-from bluesky.protocols import Movable, Stoppable
-
-from ophyd_async.core import (
-    CALCULATE_TIMEOUT,
-    DEFAULT_TIMEOUT,
-    AsyncStatus,
-    CalculatableTimeout,
-    Device,
-    StandardReadable,
-    WatchableAsyncStatus,
-    WatcherUpdate,
-    observe_value,
-)
-from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
-
-
-class Mover(StandardReadable, Movable, Stoppable):
-    """A demo movable that moves based on velocity"""
-
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        with self.add_children_as_readables(Format.HINTED_SIGNAL):
-            self.readback = epics_signal_r(float, prefix + "Readback")
-        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
-            self.velocity = epics_signal_rw(float, prefix + "Velocity")
-            self.units = epics_signal_r(str, prefix + "Readback.EGU")
-        self.setpoint = epics_signal_rw(float, prefix + "Setpoint")
-        self.precision = epics_signal_r(int, prefix + "Readback.PREC")
-        # Signals that collide with standard methods should have a trailing underscore
-        self.stop_ = epics_signal_x(prefix + "Stop.PROC")
-        # Whether set() should complete successfully or not
-        self._set_success = True
-
-        super().__init__(name=name)
-
-    def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
-        super().set_name(name, child_name_separator=child_name_separator)
-        # Readback should be named the same as its parent in read()
-        self.readback.set_name(name)
-
-    @WatchableAsyncStatus.wrap
-    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
-        new_position = value
-        self._set_success = True
-        old_position, units, precision, velocity = await asyncio.gather(
-            self.setpoint.get_value(),
-            self.units.get_value(),
-            self.precision.get_value(),
-            self.velocity.get_value(),
-        )
-        if timeout == CALCULATE_TIMEOUT:
-            assert velocity > 0, "Mover has zero velocity"
-            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
-        # Make an Event that will be set on completion, and a Status that will
-        # error if not done in time
-        done = asyncio.Event()
-        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))
-        # Wait for the value to set, but don't wait for put completion callback
-        await self.setpoint.set(new_position, wait=False)
-        async for current_position in observe_value(
-            self.readback, done_status=done_status
-        ):
-            yield WatcherUpdate(
-                current=current_position,
-                initial=old_position,
-                target=new_position,
-                name=self.name,
-                unit=units,
-                precision=precision,
-            )
-            if np.isclose(current_position, new_position):
-                done.set()
-                break
-        if not self._set_success:
-            raise RuntimeError("Motor was stopped")
-
-    async def stop(self, success=True):
-        self._set_success = success
-        status = self.stop_.trigger()
-        await status
-
-
-class SampleStage(Device):
-    """A demo sample stage with X and Y movables"""
-
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some child Devices
-        self.x = Mover(prefix + "X:")
-        self.y = Mover(prefix + "Y:")
-        # Set name of device and child devices
-        super().__init__(name=name)

ophyd_async/epics/demo/_sensor.py

@@ -1,37 +0,0 @@
-from typing import Annotated as A
-
-from ophyd_async.core import (
-    DeviceVector,
-    SignalR,
-    SignalRW,
-    StandardReadable,
-    StrictEnum,
-)
-from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.epics.core import EpicsDevice, PvSuffix
-
-
-class EnergyMode(StrictEnum):
-    """Energy mode for `Sensor`"""
-
-    #: Low energy mode
-    LOW = "Low Energy"
-    #: High energy mode
-    HIGH = "High Energy"
-
-
-class Sensor(StandardReadable, EpicsDevice):
-    """A demo sensor that produces a scalar value based on X and Y Movers"""
-
-    value: A[SignalR[float], PvSuffix("Value"), Format.HINTED_SIGNAL]
-    mode: A[SignalRW[EnergyMode], PvSuffix("Mode"), Format.CONFIG_SIGNAL]
-
-
-class SensorGroup(StandardReadable):
-    def __init__(self, prefix: str, name: str = "", sensor_count: int = 3) -> None:
-        with self.add_children_as_readables():
-            self.sensors = DeviceVector(
-                {i: Sensor(f"{prefix}{i}:") for i in range(1, sensor_count + 1)}
-            )
-
-        super().__init__(name)

ophyd_async/epics/demo/sensor.db

@@ -1,19 +0,0 @@
-record(mbbo, "$(P)Mode") {
-    field(DESC, "Energy sensitivity of the image")
-    field(DTYP, "Raw Soft Channel")
-    field(PINI, "YES")
-    field(ZRVL, "10")
-    field(ZRST, "Low Energy")
-    field(ONVL, "100")
-    field(ONST, "High Energy")
-}
-
-record(calc, "$(P)Value") {
-    field(DESC, "Sensor value simulated from X and Y")
-    field(INPA,  "$(P)X:Readback CP")
-    field(INPB,  "$(P)Y:Readback CP")
-    field(INPC,  "$(P)Mode.RVAL CP")
-    field(CALC, "SIN(A)**10+COS(C+B*A)*COS(A)")
-    field(EGU,  "$(EGU=cts/s)")
-    field(PREC, "$(PREC=3)")
-}

ophyd_async/fastcs/panda/_utils.py

@@ -1,16 +0,0 @@
-from collections.abc import Sequence
-from typing import Any
-
-
-def phase_sorter(panda_signal_values: dict[str, Any]) -> Sequence[dict[str, Any]]:
-    # Panda has two load phases. If the signal name ends in the string "UNITS",
-    # it needs to be loaded first so put in first phase
-    phase_1, phase_2 = {}, {}
-
-    for key, value in panda_signal_values.items():
-        if key.endswith("units"):
-            phase_1[key] = value
-        else:
-            phase_2[key] = value
-
-    return [phase_1, phase_2]

ophyd_async/sim/demo/__init__.py

@@ -1,19 +0,0 @@
-from ._pattern_detector import (
-    DATA_PATH,
-    SUM_PATH,
-    PatternDetector,
-    PatternDetectorController,
-    PatternDetectorWriter,
-    PatternGenerator,
-)
-from ._sim_motor import SimMotor
-
-__all__ = [
-    "DATA_PATH",
-    "SUM_PATH",
-    "PatternGenerator",
-    "PatternDetector",
-    "PatternDetectorController",
-    "PatternDetectorWriter",
-    "SimMotor",
-]

ophyd_async/sim/demo/_pattern_detector/__init__.py

@@ -1,13 +0,0 @@
-from ._pattern_detector import PatternDetector
-from ._pattern_detector_controller import PatternDetectorController
-from ._pattern_detector_writer import PatternDetectorWriter
-from ._pattern_generator import DATA_PATH, SUM_PATH, PatternGenerator
-
-__all__ = [
-    "PatternDetector",
-    "PatternDetectorController",
-    "PatternDetectorWriter",
-    "DATA_PATH",
-    "SUM_PATH",
-    "PatternGenerator",
-]