ophyd-async 0.3.4a1__py3-none-any.whl → 0.5.0__py3-none-any.whl

ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py

@@ -0,0 +1,211 @@
+from pathlib import Path
+from typing import AsyncGenerator, AsyncIterator, Dict, Optional
+
+import h5py
+import numpy as np
+from bluesky.protocols import DataKey, StreamAsset
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    HDFDataset,
+    HDFFile,
+    PathProvider,
+    observe_value,
+    soft_signal_r_and_setter,
+)
+
+# raw data path
+DATA_PATH = "/entry/data/data"
+
+# pixel sum path
+SUM_PATH = "/entry/sum"
+
+MAX_UINT8_VALUE = np.iinfo(np.uint8).max
+
+
+def generate_gaussian_blob(height: int, width: int) -> np.ndarray:
+    """Make a Gaussian Blob with float values in range 0..1"""
+    x, y = np.meshgrid(np.linspace(-1, 1, width), np.linspace(-1, 1, height))
+    d = np.sqrt(x * x + y * y)
+    blob = np.exp(-(d**2))
+    return blob
+
+
+def generate_interesting_pattern(x: float, y: float) -> float:
+    """This function is interesting in x and y in range -10..10, returning
+    a float value in range 0..1
+    """
+    z = 0.5 + (np.sin(x) ** 10 + np.cos(10 + y * x) * np.cos(x)) / 2
+    return z
+
+
+class PatternGenerator:
+    def __init__(
+        self,
+        saturation_exposure_time: float = 0.1,
+        detector_width: int = 320,
+        detector_height: int = 240,
+    ) -> None:
+        self.saturation_exposure_time = saturation_exposure_time
+        self.exposure = saturation_exposure_time
+        self.x = 0.0
+        self.y = 0.0
+        self.height = detector_height
+        self.width = detector_width
+        self.image_counter: int = 0
+
+        # it automatically initializes to 0
+        self.counter_signal, self._set_counter_signal = soft_signal_r_and_setter(int)
+        self._full_intensity_blob = (
+            generate_gaussian_blob(width=detector_width, height=detector_height)
+            * MAX_UINT8_VALUE
+        )
+        self._hdf_stream_provider: Optional[HDFFile] = None
+        self._handle_for_h5_file: Optional[h5py.File] = None
+        self.target_path: Optional[Path] = None
+
+    async def write_image_to_file(self) -> None:
+        assert self._handle_for_h5_file, "no file has been opened!"
+        # prepare - resize the fixed hdf5 data structure
+        # so that the new image can be written
+        self._handle_for_h5_file[DATA_PATH].resize(
+            (self.image_counter + 1, self.height, self.width)
+        )
+        self._handle_for_h5_file[SUM_PATH].resize((self.image_counter + 1,))
+
+        # generate the simulated data
+        intensity: float = generate_interesting_pattern(self.x, self.y)
+        detector_data = (
+            self._full_intensity_blob
+            * intensity
+            * self.exposure
+            / self.saturation_exposure_time
+        ).astype(np.uint8)
+
+        # write data to disc (intermediate step)
+        self._handle_for_h5_file[DATA_PATH][self.image_counter] = detector_data
+        sum = np.sum(detector_data)
+        self._handle_for_h5_file[SUM_PATH][self.image_counter] = sum
+
+        # save metadata - so that it's discoverable
+        self._handle_for_h5_file[DATA_PATH].flush()
+        self._handle_for_h5_file[SUM_PATH].flush()
+
+        # counter increment is last
+        # as only at this point the new data is visible from the outside
+        self.image_counter += 1
+        self._set_counter_signal(self.image_counter)
+
+    def set_exposure(self, value: float) -> None:
+        self.exposure = value
+
+    def set_x(self, value: float) -> None:
+        self.x = value
+
+    def set_y(self, value: float) -> None:
+        self.y = value
+
+    async def open_file(
+        self, path_provider: PathProvider, name: str, multiplier: int = 1
+    ) -> Dict[str, DataKey]:
+        await self.counter_signal.connect()
+
+        self.target_path = self._get_new_path(path_provider)
+        self._path_provider = path_provider
+
+        self._handle_for_h5_file = h5py.File(self.target_path, "w", libver="latest")
+
+        assert self._handle_for_h5_file, "not loaded the file right"
+
+        self._handle_for_h5_file.create_dataset(
+            name=DATA_PATH,
+            shape=(0, self.height, self.width),
+            dtype=np.uint8,
+            maxshape=(None, self.height, self.width),
+        )
+        self._handle_for_h5_file.create_dataset(
+            name=SUM_PATH,
+            shape=(0,),
+            dtype=np.float64,
+            maxshape=(None,),
+        )
+
+        # once datasets written, can switch the model to single writer multiple reader
+        self._handle_for_h5_file.swmr_mode = True
+        self.multiplier = multiplier
+
+        outer_shape = (multiplier,) if multiplier > 1 else ()
+
+        # cache state to self
+        # Add the main data
+        self._datasets = [
+            HDFDataset(
+                data_key=name,
+                dataset=DATA_PATH,
+                shape=(self.height, self.width),
+                multiplier=multiplier,
+            ),
+            HDFDataset(
+                f"{name}-sum",
+                dataset=SUM_PATH,
+                shape=(),
+                multiplier=multiplier,
+            ),
+        ]
+
+        describe = {
+            ds.data_key: DataKey(
+                source="sim://pattern-generator-hdf-file",
+                shape=outer_shape + tuple(ds.shape),
+                dtype="array" if ds.shape else "number",
+                external="STREAM:",
+            )
+            for ds in self._datasets
+        }
+        return describe
+
+    def _get_new_path(self, path_provider: PathProvider) -> Path:
+        info = path_provider(device_name="pattern")
+        filename = info.filename
+        new_path: Path = info.root / info.resource_dir / filename
+        return new_path
+
+    async def collect_stream_docs(
+        self, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
+        """
+        stream resource says "here is a dataset",
+        stream datum says "here are N frames in that stream resource",
+        you get one stream resource and many stream datums per scan
+        """
+        if self._handle_for_h5_file:
+            self._handle_for_h5_file.flush()
+        # when already something was written to the file
+        if indices_written:
+            # if no frames arrived yet, there's no file to speak of
+            # cannot get the full filename the HDF writer will write
+            # until the first frame comes in
+            if not self._hdf_stream_provider:
+                assert self.target_path, "open file has not been called"
+                self._hdf_stream_provider = HDFFile(
+                    self._path_provider(),
+                    self.target_path,
+                    self._datasets,
+                )
+                for doc in self._hdf_stream_provider.stream_resources():
+                    yield "stream_resource", doc
+            if self._hdf_stream_provider:
+                for doc in self._hdf_stream_provider.stream_data(indices_written):
+                    yield "stream_datum", doc
+
+    def close(self) -> None:
+        if self._handle_for_h5_file:
+            self._handle_for_h5_file.close()
+            print("file closed")
+            self._handle_for_h5_file = None
+
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        async for num_captured in observe_value(self.counter_signal, timeout=timeout):
+            yield num_captured // self.multiplier

ophyd_async/sim/demo/{sim_motor.py → _sim_motor.py}

@@ -4,15 +4,17 @@ import time
 
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import StandardReadable
-from ophyd_async.core.async_status import AsyncStatus, WatchableAsyncStatus
-from ophyd_async.core.signal import (
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    WatcherUpdate,
     observe_value,
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
-from ophyd_async.core.standard_readable import ConfigSignal, HintedSignal
-from ophyd_async.core.utils import WatcherUpdate
 
 
 class SimMotor(StandardReadable, Movable, Stoppable):

{ophyd_async-0.3.4a1.dist-info → ophyd_async-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3.4a1
+Version: 0.5.0
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -45,10 +45,12 @@ Requires-Dist: numpy <2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
 Requires-Dist: bluesky >=1.13.0a3
-Requires-Dist: event-model <1.21.0
+Requires-Dist: event-model
 Requires-Dist: p4p
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
+Requires-Dist: pydantic >=2.0
+Requires-Dist: pydantic-numpy
 Provides-Extra: ca
 Requires-Dist: aioca >=1.6 ; extra == 'ca'
 Provides-Extra: dev
@@ -79,10 +81,13 @@ Requires-Dist: pytest-faulthandler ; extra == 'dev'
 Requires-Dist: pytest-rerunfailures ; extra == 'dev'
 Requires-Dist: pytest-timeout ; extra == 'dev'
 Requires-Dist: ruff ; extra == 'dev'
+Requires-Dist: sphinx <7.4.0 ; extra == 'dev'
 Requires-Dist: sphinx-autobuild ; extra == 'dev'
+Requires-Dist: autodoc-pydantic ; extra == 'dev'
 Requires-Dist: sphinxcontrib-mermaid ; extra == 'dev'
 Requires-Dist: sphinx-copybutton ; extra == 'dev'
 Requires-Dist: sphinx-design ; extra == 'dev'
+Requires-Dist: super-state-machine ; extra == 'dev'
 Requires-Dist: tox-direct ; extra == 'dev'
 Requires-Dist: types-mock ; extra == 'dev'
 Requires-Dist: types-pyyaml ; extra == 'dev'

ophyd_async-0.5.0.dist-info/RECORD

@@ -0,0 +1,89 @@
+ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
+ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
+ophyd_async/_version.py,sha256=aeBju2l8GTMwAhIRG_c2Q_oVPFacRkZZwGtxmvFCGPQ,411
+ophyd_async/core/__init__.py,sha256=5TjvjpdZEAjCHsf3G5A_yrgdh0vK0KwCx-qg31f2fLs,3675
+ophyd_async/core/_detector.py,sha256=Rk7HR_QpQskhqWDwjENQL5HSj49PJWtLbWTxoQeTZKw,11228
+ophyd_async/core/_device.py,sha256=DDdRujYLCDSuGDB0gqElkzI0qEGb3sMlFP6FgmH2u3A,7554
+ophyd_async/core/_device_save_loader.py,sha256=pTom5EOFa9_5Z3bV37zOnbGx2ujWIOl_D9PVYhpY1FY,8232
+ophyd_async/core/_flyer.py,sha256=8_N9u6s2P9qPZmNtHFfdmFv8FD7sKrKb9-IuvNUVHPw,2267
+ophyd_async/core/_hdf_dataset.py,sha256=ZFfG6hmWRcExFhTxbnWB5NwuaOI_cwE4z_fjXV2Vg8s,2600
+ophyd_async/core/_log.py,sha256=Hsk2Iwx81n3HpxNR30xGTnLJh_lPGd_CGy2MI3OGpWs,3588
+ophyd_async/core/_mock_signal_backend.py,sha256=M_I2LxxJrJmBAbmILjVoAR6E2U8K2UswvHGiHluMqHc,2799
+ophyd_async/core/_mock_signal_utils.py,sha256=DSCJiwkSF1aVoUAtlsRm-3PY4Eiff4vYHjlD_QbbhdA,4696
+ophyd_async/core/_protocol.py,sha256=aRoqet0ThyVK_wrULh4k_StnpeHnNhXc0YffWdRJNZw,3391
+ophyd_async/core/_providers.py,sha256=-HlisysZZcqs6z1yQsWCpof7hQ9QTbg2IYpm4XaErGQ,7454
+ophyd_async/core/_readable.py,sha256=WayM35JOJj732-YgvGsjUSlCZwZ_zq1zbAmk-1U0uwU,8998
+ophyd_async/core/_signal.py,sha256=IE_7Enn_RU8IUg6L1bpchbMvwwA4YZdrA8S7bOKk_7o,18503
+ophyd_async/core/_signal_backend.py,sha256=-Vze8-57W0jpcC4gq4P4rZpXXJvi2qrbu0A8AjqA594,2638
+ophyd_async/core/_soft_signal_backend.py,sha256=Z4LiADd9xKrxhhPOx8q5xq4yrJRdJbfuKeB0o2wBjCk,6653
+ophyd_async/core/_status.py,sha256=mjzoGyaMFCfQLIWNKv_VcuCz9unZ9Gs3nCkaa1dTne8,4334
+ophyd_async/core/_utils.py,sha256=3oZcXNqAUHX4ZWMBH5gSuK6cFWEhSkZ9GSDYv0pf8jc,5783
+ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/epics/motor.py,sha256=z1a61P1-tA3RxeD36uhhE6WJ0AfLU6xodtdk2avV_Ss,8495
+ophyd_async/epics/adaravis/__init__.py,sha256=u979_9nQTYB0TvDOTXFN4qMrbDP8-xQFfXYMGzLVBo4,207
+ophyd_async/epics/adaravis/_aravis.py,sha256=f2xiKQr1AcX6R-NjaMMgfXBfbHIsYfDGp4-CyHKIT6I,1949
+ophyd_async/epics/adaravis/_aravis_controller.py,sha256=SzyajBNoqvBOUVtNE0t8ghffY2pYP8U99XgQ-4u2pVI,2635
+ophyd_async/epics/adaravis/_aravis_io.py,sha256=GY2thPUJ-6821GvfZTBLoX8g9d-U1YgyoXe3wYRVw-g,1554
+ophyd_async/epics/adcore/__init__.py,sha256=6L2xRXI6AvrOYGqPg0oIzYF7N9lxF9mxIVFDYELjw7I,923
+ophyd_async/epics/adcore/_core_io.py,sha256=aLl8sSYJZqPjHEVBiwWcLDsWtjCFYL-t_02KTqDiwUA,4547
+ophyd_async/epics/adcore/_core_logic.py,sha256=XpM1t2kqof9q_7fkKlFPKP2vT0DoLgc0drj7cTUHsbU,3421
+ophyd_async/epics/adcore/_hdf_writer.py,sha256=rnNNwFAr3KtNJCIk0jRGA0Fz5MPhUV3bvShG00OpG7A,5882
+ophyd_async/epics/adcore/_single_trigger.py,sha256=LGhAZV0GoRwRTNFQmgLpkfq73HsiMCu20JKYGOzxt0I,1159
+ophyd_async/epics/adcore/_utils.py,sha256=EgpofUaLV9AofcMmwLYmRybDGWRonRZNYUzWrMxoQL4,3587
+ophyd_async/epics/adkinetix/__init__.py,sha256=QEft12PURied6LRzjw-NhUmngjAm1XNA3k-5o5aMXDQ,216
+ophyd_async/epics/adkinetix/_kinetix.py,sha256=Xnt54pqxWArcBIZ8RdLMXfMX0kCDCInJQp48MMx6Gmw,1181
+ophyd_async/epics/adkinetix/_kinetix_controller.py,sha256=jHe6MSfqCOdzw0jQ5L6cYq55I0TD5Bso2ZGOZmv1j3Q,1504
+ophyd_async/epics/adkinetix/_kinetix_io.py,sha256=zm3MnJkOVCAIyHi3x3t0trAv4GlEFZMJPd8VGsn50Lc,838
+ophyd_async/epics/adpilatus/__init__.py,sha256=daimScOCCMHR2eb8VbezHOcGOkd6uIRZQiyeTQsaAx4,308
+ophyd_async/epics/adpilatus/_pilatus.py,sha256=NEim_ZROa-B0uYXYgLiiAIDzqzl-IjSCqpOrosOvcHk,1748
+ophyd_async/epics/adpilatus/_pilatus_controller.py,sha256=1dB27dZyNdcGLDDs8Lw8C0wVc_Yok0tXjGyBocI4BiE,2463
+ophyd_async/epics/adpilatus/_pilatus_io.py,sha256=jhD8RswxN0eTqPR-lMw7L9yGoT4H1ZIphguZk2GZOJM,735
+ophyd_async/epics/adsimdetector/__init__.py,sha256=t3crUgTEvVJGI8o6FsfN42k0A-l4v9ZBwXIYtixoE-M,128
+ophyd_async/epics/adsimdetector/_sim.py,sha256=nk4Xj_j_WeKk1FJov-Zo2W7NHnHcBUDbIzranHUpngI,863
+ophyd_async/epics/adsimdetector/_sim_controller.py,sha256=v0GrMXg7U1PUvLKW8zmx8zrunk_MfFt7GbckbVlnUys,1494
+ophyd_async/epics/advimba/__init__.py,sha256=GSnFWGPNJsCJZ-Tgyv-L38Smwzp2bWC64U_4uD2TLvs,198
+ophyd_async/epics/advimba/_vimba.py,sha256=qDLP5KcI0PZGgpMVmzkfxfgIt3hoiqpvNlRGrtEZxl4,1122
+ophyd_async/epics/advimba/_vimba_controller.py,sha256=R7OUQGule1HdEl4Eo7MTthU0TpLFYSAZ8l_G8G3LNxU,1995
+ophyd_async/epics/advimba/_vimba_io.py,sha256=4tYfcPgt0uD2pf3eAV7OHMCXlecG3vfvoll_EI6_neM,1802
+ophyd_async/epics/demo/__init__.py,sha256=wCrgemEo-zR4TTvaqCKnQ-AIUHorotV5jhftbq1tXz0,1368
+ophyd_async/epics/demo/_mover.py,sha256=7GEmF-mgN0qxiHUE3Tgboh0p9S5AuPBYR-pFeg5QFTk,3520
+ophyd_async/epics/demo/_sensor.py,sha256=8OyFAsB3EXMzrQreOIg_TGHrseUtI5rxXpfwwUaC76I,1165
+ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
+ophyd_async/epics/demo/sensor.db,sha256=AVtiydrdtwAz2EFurO2Ult9SSRtre3r0akOBbL98LT0,554
+ophyd_async/epics/pvi/__init__.py,sha256=ZvJO69ApL7N9rWT9-hD-JZMC_KsHxgeEqxe-01jNUVw,137
+ophyd_async/epics/pvi/_pvi.py,sha256=PUst4KhX8emkbRunLrJeqTruaOMF3mm1s7YJsBB7HpQ,12099
+ophyd_async/epics/signal/__init__.py,sha256=cJGvTnJxHNzpWyWIYXU4UGMoz3uqZ88UVXNvG-TGngo,441
+ophyd_async/epics/signal/_aioca.py,sha256=qvaEmGllNplWgzwjlAPsHhF8IgPkgYYKqn-_YV9t1pU,11408
+ophyd_async/epics/signal/_common.py,sha256=MYf34SAKUPqvMv9YKJ5-3G6zVrjhRYbpQvGXGiONSws,1848
+ophyd_async/epics/signal/_epics_transport.py,sha256=MnkhnbpYSxrS7Wo8jDJ1YGnkrvjfYEt1oOe-uxjGCPU,839
+ophyd_async/epics/signal/_p4p.py,sha256=jozZoyCC6bOtpJMWCcPLWA3sxQTf9YLo_Koq9hOVrLA,15752
+ophyd_async/epics/signal/_signal.py,sha256=i5q7zTv5y3HFQRI1JrwWT-gN6bViPWNuks14le2pTFI,3252
+ophyd_async/fastcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/fastcs/odin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/fastcs/panda/__init__.py,sha256=REtsRQCLGi9uhjYIwLL7C6n_pbJMvG_MfWY_M5wxGIQ,1187
+ophyd_async/fastcs/panda/_common_blocks.py,sha256=4wyc4iTpOuDnzFXk98l287E5Ygl9ZO9tN7s1Lp9t6CM,1542
+ophyd_async/fastcs/panda/_hdf_panda.py,sha256=KXahiaMvMm2Ox9G31QBWunYTWedXnKAKS8c63FL0AgM,1321
+ophyd_async/fastcs/panda/_hdf_writer.py,sha256=6I89I4XVUOWYA7IqmbOcL8hp9x5vFA_vJOSxAIqqRRw,5042
+ophyd_async/fastcs/panda/_panda_controller.py,sha256=ltetcf_OSQMtLVSh1uKW7Nyu5XDbb-W9iuw767cP66E,1237
+ophyd_async/fastcs/panda/_table.py,sha256=atd9wiam0XQH89doqzn0U6J42CFQBKDs9K1_q5GcJR8,6093
+ophyd_async/fastcs/panda/_trigger.py,sha256=iqmLN1Dh8n_p4amhTKSP5ifSaLhYwqqHhva0G-oVSvM,3062
+ophyd_async/fastcs/panda/_utils.py,sha256=VHW5kPVISyEkmse_qQcyisBkkEwMO6GG2Ago-CH1AFA,487
+ophyd_async/plan_stubs/__init__.py,sha256=Qn0VDrlT2CmzP32qzAeP3YFvLWdLfpveq3qGQM_4TsE,407
+ophyd_async/plan_stubs/_ensure_connected.py,sha256=6Q7_UWQ-UQ0awe6mnN4PdNCAOGRm4GZR9X2M-ghQCeI,711
+ophyd_async/plan_stubs/_fly.py,sha256=PWT7cbnVUDBFtjKkMQ7Lr960M9d0JcUBseXFYhzBc8I,6299
+ophyd_async/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/sim/demo/__init__.py,sha256=JKWFnHqmFuRRMvvU0aBuclke3OdF0iq89yvHEd4J7Bg,371
+ophyd_async/sim/demo/_sim_motor.py,sha256=Dfc-1faeqbVLsCLuM2FFJ2F20Ib0UsS2vsHdqgVt2Zk,3601
+ophyd_async/sim/demo/_pattern_detector/__init__.py,sha256=o_dSZDIl_CyS3YPSNKpGiQiR9UaC4cNzZ8_ByEN9dIk,402
+ophyd_async/sim/demo/_pattern_detector/_pattern_detector.py,sha256=5PH9vZ0vLhhvzN1H-7HUcaNUOQ---9i0GEBKY_luRTI,1278
+ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py,sha256=JJ6iQexK--ODJ8am9hIu4LARzuYvdNhqHjPE6KcCdJI,1717
+ophyd_async/sim/demo/_pattern_detector/_pattern_detector_writer.py,sha256=ayJJ2Y0rqM7gIEtxhH4-iRnYi0RQTaEWFIHUJd2W27Y,1280
+ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py,sha256=ksgXyyErAdvFKac4vuJLB_9aXBqLzbCEZ4_ag7hFpE4,7257
+ophyd_async/sim/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/tango/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async-0.5.0.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.5.0.dist-info/METADATA,sha256=uExqBPoTfChURS_0SJ0AZ0ktukzZYMOZ1AcXKMOJj80,6491
+ophyd_async-0.5.0.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+ophyd_async-0.5.0.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.5.0.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.5.0.dist-info/RECORD,,

{ophyd_async-0.3.4a1.dist-info → ophyd_async-0.5.0.dist-info}/WHEEL

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

ophyd_async/epics/areadetector/__init__.py

@@ -1,23 +0,0 @@
-from .aravis import AravisDetector
-from .kinetix import KinetixDetector
-from .pilatus import PilatusDetector
-from .single_trigger_det import SingleTriggerDet
-from .utils import (
-    FileWriteMode,
-    ImageMode,
-    NDAttributeDataType,
-    NDAttributesXML,
-)
-from .vimba import VimbaDetector
-
-__all__ = [
-    "AravisDetector",
-    "KinetixDetector",
-    "VimbaDetector",
-    "SingleTriggerDet",
-    "FileWriteMode",
-    "ImageMode",
-    "NDAttributeDataType",
-    "NDAttributesXML",
-    "PilatusDetector",
-]

ophyd_async/epics/areadetector/controllers/__init__.py

@@ -1,5 +0,0 @@
-from .ad_sim_controller import ADSimController
-from .aravis_controller import AravisController
-from .pilatus_controller import PilatusController
-
-__all__ = ["PilatusController", "ADSimController", "AravisController"]

ophyd_async/epics/areadetector/drivers/__init__.py

@@ -1,23 +0,0 @@
-from .ad_base import (
-    ADBase,
-    ADBaseShapeProvider,
-    DetectorState,
-    set_exposure_time_and_acquire_period_if_supplied,
-    start_acquiring_driver_and_ensure_status,
-)
-from .aravis_driver import AravisDriver
-from .kinetix_driver import KinetixDriver
-from .pilatus_driver import PilatusDriver
-from .vimba_driver import VimbaDriver
-
-__all__ = [
-    "ADBase",
-    "ADBaseShapeProvider",
-    "PilatusDriver",
-    "AravisDriver",
-    "KinetixDriver",
-    "VimbaDriver",
-    "start_acquiring_driver_and_ensure_status",
-    "set_exposure_time_and_acquire_period_if_supplied",
-    "DetectorState",
-]

ophyd_async/epics/areadetector/vimba.py

@@ -1,43 +0,0 @@
-from bluesky.protocols import HasHints, Hints
-
-from ophyd_async.core import DirectoryProvider, StandardDetector
-from ophyd_async.epics.areadetector.controllers.vimba_controller import VimbaController
-from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
-from ophyd_async.epics.areadetector.drivers.vimba_driver import VimbaDriver
-from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
-
-
-class VimbaDetector(StandardDetector, HasHints):
-    """
-    Ophyd-async implementation of an ADVimba Detector.
-    """
-
-    _controller: VimbaController
-    _writer: HDFWriter
-
-    def __init__(
-        self,
-        prefix: str,
-        directory_provider: DirectoryProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
-    ):
-        self.drv = VimbaDriver(prefix + drv_suffix)
-        self.hdf = NDFileHDF(prefix + hdf_suffix)
-
-        super().__init__(
-            VimbaController(self.drv),
-            HDFWriter(
-                self.hdf,
-                directory_provider,
-                lambda: self.name,
-                ADBaseShapeProvider(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_time,),
-            name=name,
-        )
-
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints

ophyd_async/epics/areadetector/writers/__init__.py

@@ -1,5 +0,0 @@
-from .hdf_writer import HDFWriter
-from .nd_file_hdf import NDFileHDF
-from .nd_plugin import NDPluginBase, NDPluginStats
-
-__all__ = ["HDFWriter", "NDFileHDF", "NDPluginBase", "NDPluginStats"]

ophyd_async/epics/areadetector/writers/_hdfdataset.py

@@ -1,10 +0,0 @@
-from dataclasses import dataclass
-from typing import Sequence
-
-
-@dataclass
-class _HDFDataset:
-    name: str
-    path: str
-    shape: Sequence[int]
-    multiplier: int

ophyd_async/epics/areadetector/writers/_hdffile.py

@@ -1,54 +0,0 @@
-from pathlib import Path
-from typing import Iterator, List
-
-from event_model import StreamDatum, StreamResource, compose_stream_resource
-
-from ophyd_async.core import DirectoryInfo
-
-from ._hdfdataset import _HDFDataset
-
-
-class _HDFFile:
-    """
-    :param directory_info: Contains information about how to construct a StreamResource
-    :param full_file_name: Absolute path to the file to be written
-    :param datasets: Datasets to write into the file
-    """
-
-    def __init__(
-        self,
-        directory_info: DirectoryInfo,
-        full_file_name: Path,
-        datasets: List[_HDFDataset],
-    ) -> None:
-        self._last_emitted = 0
-        self._bundles = [
-            compose_stream_resource(
-                spec="AD_HDF5_SWMR_SLICE",
-                root=str(directory_info.root),
-                data_key=ds.name,
-                resource_path=str(full_file_name.relative_to(directory_info.root)),
-                resource_kwargs={
-                    "path": ds.path,
-                    "multiplier": ds.multiplier,
-                    "timestamps": "/entry/instrument/NDAttributes/NDArrayTimeStamp",
-                },
-            )
-            for ds in datasets
-        ]
-
-    def stream_resources(self) -> Iterator[StreamResource]:
-        for bundle in self._bundles:
-            yield bundle.stream_resource_doc
-
-    def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
-        # Indices are relative to resource
-        if indices_written > self._last_emitted:
-            indices = {
-                "start": self._last_emitted,
-                "stop": indices_written,
-            }
-            self._last_emitted = indices_written
-            for bundle in self._bundles:
-                yield bundle.compose_stream_datum(indices)
-        return None

ophyd_async/epics/areadetector/writers/nd_file_hdf.py

@@ -1,40 +0,0 @@
-from enum import Enum
-
-from ...signal.signal import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
-from ..utils import FileWriteMode
-from .nd_plugin import NDPluginBase
-
-
-class Compression(str, Enum):
-    none = "None"
-    nbit = "N-bit"
-    szip = "szip"
-    zlib = "zlib"
-    blosc = "Blosc"
-    bslz4 = "BSLZ4"
-    lz4 = "LZ4"
-    jpeg = "JPEG"
-
-
-class NDFileHDF(NDPluginBase):
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        self.position_mode = epics_signal_rw_rbv(bool, prefix + "PositionMode")
-        self.compression = epics_signal_rw_rbv(Compression, prefix + "Compression")
-        self.num_extra_dims = epics_signal_rw_rbv(int, prefix + "NumExtraDims")
-        self.file_path = epics_signal_rw_rbv(str, prefix + "FilePath")
-        self.file_name = epics_signal_rw_rbv(str, prefix + "FileName")
-        self.file_path_exists = epics_signal_r(bool, prefix + "FilePathExists_RBV")
-        self.file_template = epics_signal_rw_rbv(str, prefix + "FileTemplate")
-        self.full_file_name = epics_signal_r(str, prefix + "FullFileName_RBV")
-        self.file_write_mode = epics_signal_rw_rbv(
-            FileWriteMode, prefix + "FileWriteMode"
-        )
-        self.num_capture = epics_signal_rw_rbv(int, prefix + "NumCapture")
-        self.num_captured = epics_signal_r(int, prefix + "NumCaptured_RBV")
-        self.swmr_mode = epics_signal_rw_rbv(bool, prefix + "SWMRMode")
-        self.lazy_open = epics_signal_rw_rbv(bool, prefix + "LazyOpen")
-        self.capture = epics_signal_rw_rbv(bool, prefix + "Capture")
-        self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
-        self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
-        super().__init__(prefix, name)

ophyd_async/epics/areadetector/writers/nd_plugin.py

@@ -1,38 +0,0 @@
-from enum import Enum
-
-from ophyd_async.core import Device
-from ophyd_async.epics.signal import epics_signal_rw
-from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw_rbv
-
-
-class Callback(str, Enum):
-    Enable = "Enable"
-    Disable = "Disable"
-
-
-class NDArrayBase(Device):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
-        self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
-        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
-        self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
-        self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
-        self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
-        # There is no _RBV for this one
-        self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")
-
-        super().__init__(name=name)
-
-
-class NDPluginBase(NDArrayBase):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
-        self.enable_callback = epics_signal_rw_rbv(Callback, prefix + "EnableCallbacks")
-        self.nd_array_address = epics_signal_rw_rbv(int, prefix + "NDArrayAddress")
-        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0_RBV")
-        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1_RBV")
-        super().__init__(prefix, name)
-
-
-class NDPluginStats(NDPluginBase):
-    pass

ophyd_async/epics/demo/demo_ad_sim_detector.py

@@ -1,35 +0,0 @@
-from typing import Sequence
-
-from ophyd_async.core import DirectoryProvider, SignalR, StandardDetector
-
-from ..areadetector.controllers import ADSimController
-from ..areadetector.drivers import ADBase, ADBaseShapeProvider
-from ..areadetector.writers import HDFWriter, NDFileHDF
-
-
-class DemoADSimDetector(StandardDetector):
-    _controller: ADSimController
-    _writer: HDFWriter
-
-    def __init__(
-        self,
-        drv: ADBase,
-        hdf: NDFileHDF,
-        directory_provider: DirectoryProvider,
-        name: str = "",
-        config_sigs: Sequence[SignalR] = (),
-    ):
-        self.drv = drv
-        self.hdf = hdf
-
-        super().__init__(
-            ADSimController(self.drv),
-            HDFWriter(
-                self.hdf,
-                directory_provider,
-                lambda: self.name,
-                ADBaseShapeProvider(self.drv),
-            ),
-            config_sigs=config_sigs,
-            name=name,
-        )

ophyd_async/epics/motion/__init__.py

@@ -1,3 +0,0 @@
-from .motor import Motor
-
-__all__ = ["Motor"]