ophyd-async 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

ophyd_async-0.3.0.dist-info/RECORD

@@ -0,0 +1,86 @@
+ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
+ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
+ophyd_async/_version.py,sha256=Jk2iAU7m-7Vx9XV1TtdD9ZoJraIncDq_4_Wd-qtUotg,411
+ophyd_async/log.py,sha256=DbMjt0bkfUOLHIinZYt0Q0FHZmCXXi5x8y0uFiEmqoQ,3587
+ophyd_async/protocols.py,sha256=EF2W9nfElV-0QNMYrX1zusL1PqDJR3kNsjlalR29j0I,3412
+ophyd_async/core/__init__.py,sha256=znjVeRfrDVJbGLEkUczeKMW46kV6HDrlE4lV0SqvZt4,2952
+ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
+ophyd_async/core/async_status.py,sha256=9TOgOXIAuH62RDo5t-Y5GdjrJ76d_6TFlBxYv-5_a88,4367
+ophyd_async/core/detector.py,sha256=8mdLKphirgit5CVCklJI9eHqKKiCz4CYs9BElo10-lc,11007
+ophyd_async/core/device.py,sha256=280zFnLCoiMZAA-Dh1_AjUSnhxUfKYGgj4H_2S1njOA,7086
+ophyd_async/core/device_save_loader.py,sha256=RXA3dPUPihAR2ZGDStlGiA-TAsr_xqL0snsCjMsMnfA,9138
+ophyd_async/core/flyer.py,sha256=bIjzBkrl8HVAlKgsZ_FF0WL69Qvksyzp9ZWmTLl8Yrw,2304
+ophyd_async/core/mock_signal_backend.py,sha256=Ug6jK72wm9vM6EueoUrYgcXtiFzdPUEISRe86LdyYKc,2844
+ophyd_async/core/mock_signal_utils.py,sha256=bF8MVZA1j9zCmS2tBbgUdfwNmcHniHixnmotjd0g7hs,4083
+ophyd_async/core/signal.py,sha256=FbTb5qDPLhVxEbh6gimqXfkZwcqB4ymHTEYVXZVZYrk,16456
+ophyd_async/core/signal_backend.py,sha256=fT3q0WED3JHmNKYCs7PzDLCK4cUPVin3wQjDNPdHqAY,1525
+ophyd_async/core/soft_signal_backend.py,sha256=56zvcEi4c8n1yYbafTbp7X0VhSkhoehm3L8RBhu2fik,5596
+ophyd_async/core/standard_readable.py,sha256=uVG3vs3s7-Kzg5dRCtT4I2mhZPqwVGYy2dxNmaOpDVU,8980
+ophyd_async/core/utils.py,sha256=3oZcXNqAUHX4ZWMBH5gSuK6cFWEhSkZ9GSDYv0pf8jc,5783
+ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/epics/_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/epics/_backend/_aioca.py,sha256=cpPNZmRMi7FnAh2-3ec5uklLVFOqsmEmpI1nh5Ud1Ls,8794
+ophyd_async/epics/_backend/_p4p.py,sha256=lIKx7kQ2o8h3M4wPwrq8JBo8xuDnasJxpDH2ATVBY78,12257
+ophyd_async/epics/_backend/common.py,sha256=16mAuxDwA3eZFjUW8DHMabaW3CtEI0Qe8DLpP2xlW7Y,814
+ophyd_async/epics/areadetector/__init__.py,sha256=ViKzx-wUxkRyNR33wfpL11QB97o0J47_KMyI2C_NphI,510
+ophyd_async/epics/areadetector/aravis.py,sha256=YklN4V0loqUQBs4swVX304N49JIGPvrNOk8iA5EWofg,2127
+ophyd_async/epics/areadetector/kinetix.py,sha256=7rE2MLnz9DEmeiN9pCekDfpXuZ2DErnMajRp_9eoLZY,1359
+ophyd_async/epics/areadetector/pilatus.py,sha256=ki-BOBCEIiUD2wAtmujBIB1eX-nbXB4yMLJK_Q3opRM,1398
+ophyd_async/epics/areadetector/single_trigger_det.py,sha256=U92dqhioIfnve3jtCThq9gXBCdEzzqzY4ezk6rZV19g,1182
+ophyd_async/epics/areadetector/utils.py,sha256=p66UbVdKRFj6Sm1Qvm23kmlVyBMMqIvXFxA3x17YnSk,2824
+ophyd_async/epics/areadetector/vimba.py,sha256=IxG8KLzfb84iLtzf6ZoX9JikqZLP49lwkWu33bkDV9Y,1291
+ophyd_async/epics/areadetector/controllers/__init__.py,sha256=af58ci7X2z2s_FyUwR3IGQrws8q4TKcBw7vFyIS5FoI,217
+ophyd_async/epics/areadetector/controllers/ad_sim_controller.py,sha256=mthZ6WxajMEgUKptq3bnkIctbLhjzTagV66i1auB8cg,1587
+ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=CIfnZdq_NobO_UMC2TJoAfUEP9GlzZg5z5bz6Dn1DxY,2669
+ophyd_async/epics/areadetector/controllers/kinetix_controller.py,sha256=9QmydX85QOXfQL_UX49M9EQ2b2hUZPVzLxgGQn-A9Oc,1611
+ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=cd1CKkaXlwkpQ0I1VL7nN0U8R4VweTsa08WhvHYI4nY,2243
+ophyd_async/epics/areadetector/controllers/vimba_controller.py,sha256=Eh4Hr9rWgq1mKvE93JzgixntjPHxF3_07GTFqiOdZqE,2123
+ophyd_async/epics/areadetector/drivers/__init__.py,sha256=-Ib0Lz4fFQQmB7K0uFxMDvAerkLxadMQERH7lNAvrs4,495
+ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=18WFAiWEUg0H2LcvTQHrKYj2wThGafQzDpiyAWki6vo,3411
+ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=PmIygsVNoxxYHvZZzFAbAm2DXmXFc13nAzL_DJB6YSU,1464
+ophyd_async/epics/areadetector/drivers/kinetix_driver.py,sha256=yIV23BkGBJ4i0VskLiLL7AFbadCCR6Ch1UwUDJ9r2YM,743
+ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=0DsUu9vAPXDa2v8_V0f_kPjBtLu3y4_EkmFfFjYO4Gk,553
+ophyd_async/epics/areadetector/drivers/vimba_driver.py,sha256=J54VtWkOklfbSqZYxGWH1e6Uzm9_Gph_ZbCf9Zax0LU,1713
+ophyd_async/epics/areadetector/writers/__init__.py,sha256=tpPcrYd1hs8WS7C0gmCnR2EBwjE5RzCljI7WwZ2V_LM,191
+ophyd_async/epics/areadetector/writers/_hdfdataset.py,sha256=E0C9VgsPyY35h7k0mvcIhjsIVNavApLxizqNWlM388w,167
+ophyd_async/epics/areadetector/writers/_hdffile.py,sha256=YtUgOKX53m0TaFEGBW671qXqNuuEKxEyLV5Ein1fjvo,1799
+ophyd_async/epics/areadetector/writers/hdf_writer.py,sha256=ZpbVilNVv81OpbCrqaeZUoHLarrjzRWEGe-zI1Wxyyw,5436
+ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=EkiaEh_0U6Iz17jFi2IIsRPsVQTQIJRG8EPNCiAHkkU,1762
+ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=GUzaeTMdG07Rb1x0WzBBxMEltBhr10jb5dL29tEWXEQ,1547
+ophyd_async/epics/demo/__init__.py,sha256=ZcuZ66aIQ58WSydLOSKnk-h_W-aWjhDRZkWQA6f3sig,5790
+ophyd_async/epics/demo/demo_ad_sim_detector.py,sha256=06y65yvaqXvL2rDocjYyLz9kTVzuwV-LeuPhEfExdOA,944
+ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
+ophyd_async/epics/demo/sensor.db,sha256=AVtiydrdtwAz2EFurO2Ult9SSRtre3r0akOBbL98LT0,554
+ophyd_async/epics/motion/__init__.py,sha256=tnmVRIwKa9PdN_xonJdAUD04UpEceh-hoD7XI62yDB0,46
+ophyd_async/epics/motion/motor.py,sha256=G8cc-okSXJ6s2fGxRO155xm7PrBbVImBmBMRWts895k,3630
+ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
+ophyd_async/epics/pvi/pvi.py,sha256=PJdY3rCRyIQbsbHDru-TJ-IVOItyaQwCQKAC0Widu6A,11363
+ophyd_async/epics/signal/__init__.py,sha256=JXKBSGpRL9y3auh27JRxsqDn_rBOXpJjtd4nCuDOX2g,261
+ophyd_async/epics/signal/_epics_transport.py,sha256=DEIL0iYUAWssysVEgWGu1fHSM1l-ATV2kjUgPtDN9LY,858
+ophyd_async/epics/signal/signal.py,sha256=M8ZVG_zLdYJfroCRX-u_w8c3yIhswSRw8e3RkW2szio,3166
+ophyd_async/panda/__init__.py,sha256=FuSnvp-RtdA0X4RcHEF0nTiXymRts2MNdFmF_1_i41w,775
+ophyd_async/panda/_common_blocks.py,sha256=n0PPc1rar43oDSIA-yNubTc8fR5YCW1tyjQU58whsg0,1038
+ophyd_async/panda/_hdf_panda.py,sha256=QjfZyYos0ZBlIqBiZ5UbyEd_wuh_cGzwV8QE9jvLiIY,1419
+ophyd_async/panda/_panda_controller.py,sha256=dIqcjmaIHVrki8UXSoDx46kk6I2Lhpe2o3sXNg5f-RQ,1238
+ophyd_async/panda/_table.py,sha256=dLoRP4zYNOkD_s0Vkp2wVYAwkjVG8nNdf8-FaXOTfPo,5655
+ophyd_async/panda/_trigger.py,sha256=tBH8uq_4o1ASG9yofVxq3tjf5v8LPzniDTRL4yjramI,1195
+ophyd_async/panda/_utils.py,sha256=VHW5kPVISyEkmse_qQcyisBkkEwMO6GG2Ago-CH1AFA,487
+ophyd_async/panda/writers/__init__.py,sha256=xy7BguVQG4HNIDBfKPjMj0KQo1tptC9LbCpEuMcVGaM,70
+ophyd_async/panda/writers/_hdf_writer.py,sha256=vnyIg3JmlzMIIq75o0IDMfGzBm_GJAhOUisAZE_0cyg,7597
+ophyd_async/panda/writers/_panda_hdf_file.py,sha256=42iHaTax4JjOBpNC7d4nkNL9SM14OTnFPTIcXv2jg-4,1759
+ophyd_async/plan_stubs/__init__.py,sha256=nO9ELG9J7fYwfVTVRWVorz4kffeszYpwk1ROh6Ha--w,405
+ophyd_async/plan_stubs/ensure_connected.py,sha256=1MkDu8UqVRPHLnW9IXRn-QvKiG8-rCV8T4KDbjf9K6w,557
+ophyd_async/plan_stubs/fly.py,sha256=nl8XLoY7hvlam6H3zl4NcPRUiEJ3xIjopHEfA0ehTDg,4845
+ophyd_async/sim/__init__.py,sha256=ScjH1g7FMo5yPACfJRZE6xGBWCHU4bKDzNQk1tqObnA,366
+ophyd_async/sim/pattern_generator.py,sha256=pvSk2zb82D08j2jiKAMqMAfRohGnYd_rpjUraLrCD6c,10640
+ophyd_async/sim/sim_pattern_detector_control.py,sha256=Ypz8IuRYAY2J243IhVbNyGr_Z-XtpJZ1qxma6NR3TgM,1838
+ophyd_async/sim/sim_pattern_detector_writer.py,sha256=ESpcVyHd1TP7Cojznv2hJAwLinu3XbgAiVKfX12FCII,1237
+ophyd_async/sim/sim_pattern_generator.py,sha256=fbcwWxTPYKLK33OzIY15vGylnonOO8HIudz1y_56GZU,1336
+ophyd_async/sim/demo/__init__.py,sha256=9mxKpslrL89cfSj4g3og8Br3O--pMj3hhWZS-Xu6kyA,56
+ophyd_async/sim/demo/sim_motor.py,sha256=a2p5wnHXjF-V5zOFai7jnszk4kbGmrZRnUqBtkOgEfQ,3733
+ophyd_async-0.3.0.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.3.0.dist-info/METADATA,sha256=aNVgEtFpaffvpH6YavrgqWN48m0HO0m38POJ17FPjGM,6285
+ophyd_async-0.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ophyd_async-0.3.0.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.3.0.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.3.0.dist-info/RECORD,,

{ophyd_async-0.1.0.dist-info → ophyd_async-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ophyd_async/core/_device/device.py

@@ -1,60 +0,0 @@
-"""Base device"""
-from __future__ import annotations
-
-from typing import Iterator, Optional, Tuple
-
-from bluesky.protocols import HasName
-
-from ..utils import wait_for_connection
-
-
-class Device(HasName):
-    """Common base class for all Ophyd Async Devices.
-
-    By default, names and connects all Device children.
-    """
-
-    _name: str = ""
-    #: The parent Device if it exists
-    parent: Optional[Device] = None
-
-    def __init__(self, name: str = "") -> None:
-        self.set_name(name)
-
-    @property
-    def name(self) -> str:
-        """Return the name of the Device"""
-        return self._name
-
-    def children(self) -> Iterator[Tuple[str, Device]]:
-        for attr_name, attr in self.__dict__.items():
-            if attr_name != "parent" and isinstance(attr, Device):
-                yield attr_name, attr
-
-    def set_name(self, name: str):
-        """Set ``self.name=name`` and each ``self.child.name=name+"-child"``.
-
-        Parameters
-        ----------
-        name:
-            New name to set
-        """
-        self._name = name
-        for attr_name, child in self.children():
-            child_name = f"{name}-{attr_name.rstrip('_')}" if name else ""
-            child.set_name(child_name)
-            child.parent = self
-
-    async def connect(self, sim: bool = False):
-        """Connect self and all child Devices.
-
-        Parameters
-        ----------
-        sim:
-            If True then connect in simulation mode.
-        """
-        coros = {
-            name: child_device.connect(sim) for name, child_device in self.children()
-        }
-        if coros:
-            await wait_for_connection(**coros)

ophyd_async/core/_device/device_collector.py

@@ -1,121 +0,0 @@
-"""Interface for connecting and naming multiple devices"""
-import asyncio
-import logging
-import sys
-from contextlib import suppress
-from typing import Any, Dict, Set
-
-from bluesky.run_engine import call_in_bluesky_event_loop
-
-from ..utils import NotConnected
-from .device import Device
-
-
-class DeviceCollector:
-    """Collector of top level Device instances to be used as a context manager
-
-    Parameters
-    ----------
-    set_name:
-        If True, call ``device.set_name(variable_name)`` on all collected
-        Devices
-    connect:
-        If True, call ``device.connect(sim)`` in parallel on all
-        collected Devices
-    sim:
-        If True, connect Signals in simulation mode
-    timeout:
-        How long to wait for connect before logging an exception
-
-    Notes
-    -----
-    Example usage::
-
-        [async] with DeviceCollector():
-            t1x = motor.Motor("BLxxI-MO-TABLE-01:X")
-            t1y = motor.Motor("pva://BLxxI-MO-TABLE-01:Y")
-            # Names and connects devices here
-        assert t1x.comm.velocity.source
-        assert t1x.name == "t1x"
-
-    """
-
-    def __init__(
-        self,
-        set_name=True,
-        connect=True,
-        sim=False,
-        timeout: float = 10.0,
-    ):
-        self._set_name = set_name
-        self._connect = connect
-        self._sim = sim
-        self._timeout = timeout
-        self._names_on_enter: Set[str] = set()
-        self._objects_on_exit: Dict[str, Any] = {}
-
-    def _caller_locals(self):
-        """Walk up until we find a stack frame that doesn't have us as self"""
-        try:
-            raise ValueError
-        except ValueError:
-            _, _, tb = sys.exc_info()
-            assert tb, "Can't get traceback, this shouldn't happen"
-            caller_frame = tb.tb_frame
-            while caller_frame.f_locals.get("self", None) is self:
-                caller_frame = caller_frame.f_back
-            return caller_frame.f_locals
-
-    def __enter__(self) -> "DeviceCollector":
-        # Stash the names that were defined before we were called
-        self._names_on_enter = set(self._caller_locals())
-        return self
-
-    async def __aenter__(self) -> "DeviceCollector":
-        return self.__enter__()
-
-    async def _on_exit(self) -> None:
-        # Name and kick off connect for devices
-        tasks: Dict[asyncio.Task, str] = {}
-        for name, obj in self._objects_on_exit.items():
-            if name not in self._names_on_enter and isinstance(obj, Device):
-                if self._set_name and not obj.name:
-                    obj.set_name(name)
-                if self._connect:
-                    task = asyncio.create_task(obj.connect(self._sim))
-                    tasks[task] = name
-        # Wait for all the signals to have finished
-        if tasks:
-            await self._wait_for_tasks(tasks)
-
-    async def _wait_for_tasks(self, tasks: Dict[asyncio.Task, str]):
-        done, pending = await asyncio.wait(tasks, timeout=self._timeout)
-        if pending:
-            msg = f"{len(pending)} Devices did not connect:"
-            for t in pending:
-                t.cancel()
-                with suppress(Exception):
-                    await t
-                e = t.exception()
-                msg += f"\n  {tasks[t]}: {type(e).__name__}"
-                lines = str(e).splitlines()
-                if len(lines) <= 1:
-                    msg += f": {e}"
-                else:
-                    msg += "".join(f"\n    {line}" for line in lines)
-            logging.error(msg)
-        raised = [t for t in done if t.exception()]
-        if raised:
-            logging.error(f"{len(raised)} Devices raised an error:")
-            for t in raised:
-                logging.exception(f"  {tasks[t]}:", exc_info=t.exception())
-        if pending or raised:
-            raise NotConnected("Not all Devices connected")
-
-    async def __aexit__(self, type, value, traceback):
-        self._objects_on_exit = self._caller_locals()
-        await self._on_exit()
-
-    def __exit__(self, type_, value, traceback):
-        self._objects_on_exit = self._caller_locals()
-        return call_in_bluesky_event_loop(self._on_exit())

ophyd_async/core/_device/device_vector.py

@@ -1,14 +0,0 @@
-"""Dictionary which can contain mappings between integers and devices."""
-
-from typing import Dict, Generator, Tuple, TypeVar
-
-from .device import Device
-
-VT = TypeVar("VT", bound=Device)
-
-
-class DeviceVector(Dict[int, VT], Device):
-    def children(self) -> Generator[Tuple[str, Device], None, None]:
-        for attr_name, attr in self.items():
-            if isinstance(attr, Device):
-                yield str(attr_name), attr

ophyd_async/core/_device/standard_readable.py

@@ -1,72 +0,0 @@
-from typing import Dict, Sequence, Tuple
-
-from bluesky.protocols import Configurable, Descriptor, Readable, Reading, Stageable
-
-from ..async_status import AsyncStatus
-from ..utils import merge_gathered_dicts
-from ._signal.signal import SignalR
-from .device import Device
-
-
-class StandardReadable(Device, Readable, Configurable, Stageable):
-    """Device that owns its children and provides useful default behavior.
-
-    - When its name is set it renames child Devices
-    - Signals can be registered for read() and read_configuration()
-    - These signals will be subscribed for read() between stage() and unstage()
-    """
-
-    _read_signals: Tuple[SignalR, ...] = ()
-    _configuration_signals: Tuple[SignalR, ...] = ()
-    _read_uncached_signals: Tuple[SignalR, ...] = ()
-
-    def set_readable_signals(
-        self,
-        read: Sequence[SignalR] = (),
-        config: Sequence[SignalR] = (),
-        read_uncached: Sequence[SignalR] = (),
-    ):
-        """
-        Parameters
-        ----------
-        read:
-            Signals to make up :meth:`~StandardReadable.read`
-        conf:
-            Signals to make up :meth:`~StandardReadable.read_configuration`
-        read_uncached:
-            Signals to make up :meth:`~StandardReadable.read` that won't be cached
-        """
-        self._read_signals = tuple(read)
-        self._configuration_signals = tuple(config)
-        self._read_uncached_signals = tuple(read_uncached)
-
-    @AsyncStatus.wrap
-    async def stage(self) -> None:
-        for sig in self._read_signals + self._configuration_signals:
-            await sig.stage().task
-
-    @AsyncStatus.wrap
-    async def unstage(self) -> None:
-        for sig in self._read_signals + self._configuration_signals:
-            await sig.unstage().task
-
-    async def describe_configuration(self) -> Dict[str, Descriptor]:
-        return await merge_gathered_dicts(
-            [sig.describe() for sig in self._configuration_signals]
-        )
-
-    async def read_configuration(self) -> Dict[str, Reading]:
-        return await merge_gathered_dicts(
-            [sig.read() for sig in self._configuration_signals]
-        )
-
-    async def describe(self) -> Dict[str, Descriptor]:
-        return await merge_gathered_dicts(
-            [sig.describe() for sig in self._read_signals + self._read_uncached_signals]
-        )
-
-    async def read(self) -> Dict[str, Reading]:
-        return await merge_gathered_dicts(
-            [sig.read() for sig in self._read_signals]
-            + [sig.read(cached=False) for sig in self._read_uncached_signals]
-        )

ophyd_async/epics/areadetector/ad_driver.py

@@ -1,18 +0,0 @@
-from ophyd_async.core import Device
-
-from ..signal.signal import epics_signal_rw
-from .utils import ImageMode, ad_r, ad_rw
-
-
-class ADDriver(Device):
-    def __init__(self, prefix: str) -> None:
-        # Define some signals
-        self.acquire = ad_rw(bool, prefix + "Acquire")
-        self.acquire_time = ad_rw(float, prefix + "AcquireTime")
-        self.num_images = ad_rw(int, prefix + "NumImages")
-        self.image_mode = ad_rw(ImageMode, prefix + "ImageMode")
-        self.array_counter = ad_rw(int, prefix + "ArrayCounter")
-        self.array_size_x = ad_r(int, prefix + "ArraySizeX")
-        self.array_size_y = ad_r(int, prefix + "ArraySizeY")
-        # There is no _RBV for this one
-        self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")

ophyd_async/epics/areadetector/directory_provider.py

@@ -1,18 +0,0 @@
-import tempfile
-from abc import abstractmethod
-from pathlib import Path
-from typing import Protocol
-
-
-class DirectoryProvider(Protocol):
-    @abstractmethod
-    async def get_directory(self) -> Path:
-        ...
-
-
-class TmpDirectoryProvider(DirectoryProvider):
-    def __init__(self) -> None:
-        self._directory = Path(tempfile.mkdtemp())
-
-    async def get_directory(self) -> Path:
-        return self._directory

ophyd_async/epics/areadetector/hdf_streamer_det.py

@@ -1,167 +0,0 @@
-import asyncio
-import collections
-import time
-from typing import Callable, Dict, Iterator, Optional, Sized
-
-from bluesky.protocols import (
-    Asset,
-    Descriptor,
-    Flyable,
-    PartialEvent,
-    WritesExternalAssets,
-)
-from bluesky.utils import new_uid
-from event_model import compose_stream_resource
-
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    AsyncStatus,
-    StandardReadable,
-    set_and_wait_for_value,
-)
-
-from .ad_driver import ADDriver
-from .directory_provider import DirectoryProvider
-from .nd_file_hdf import NDFileHDF
-from .utils import FileWriteMode, ImageMode
-
-# How long in seconds to wait between flushes of HDF datasets
-FLUSH_PERIOD = 0.5
-
-# How long to wait for new frames before timing out
-FRAME_TIMEOUT = 120
-
-
-class _HDFResource:
-    def __init__(self) -> None:
-        # TODO: set to Deque[Asset] after protocols updated for stream*
-        #   https://github.com/bluesky/bluesky/issues/1558
-        self.asset_docs = collections.deque()  # type: ignore
-        self._last_emitted = 0
-        self._last_flush = time.monotonic()
-        self._compose_datum: Optional[Callable] = None
-
-    def _append_resource(self, full_file_name: str):
-        resource_doc, (self._compose_datum,) = compose_stream_resource(
-            spec="AD_HDF5_SWMR_SLICE",
-            root="/",
-            resource_path=full_file_name,
-            resource_kwargs={},
-            stream_names=["primary"],
-        )
-        self.asset_docs.append(("stream_resource", resource_doc))
-
-    def _append_datum(self, event_count: int):
-        assert self._compose_datum, "Resource not emitted yet"
-        datum_doc = self._compose_datum(
-            datum_kwargs={},
-            event_offset=self._last_emitted,
-            event_count=event_count,
-        )
-        self._last_emitted += event_count
-        self.asset_docs.append(("stream_datum", datum_doc))
-
-    async def flush_and_publish(self, hdf: NDFileHDF):
-        num_captured = await hdf.num_captured.get_value()
-        if num_captured:
-            if self._compose_datum is None:
-                self._append_resource(await hdf.full_file_name.get_value())
-            event_count = num_captured - self._last_emitted
-            if event_count:
-                self._append_datum(event_count)
-                await hdf.flush_now.set(True)
-                self._last_flush = time.monotonic()
-        if time.monotonic() - self._last_flush > FRAME_TIMEOUT:
-            raise TimeoutError(f"{hdf.name}: writing stalled on frame {num_captured}")
-
-
-class HDFStreamerDet(StandardReadable, Flyable, WritesExternalAssets):
-    def __init__(
-        self, drv: ADDriver, hdf: NDFileHDF, dp: DirectoryProvider, name=""
-    ) -> None:
-        self.drv = drv
-        self.hdf = hdf
-        self._dp = dp
-        self._resource = _HDFResource()
-        self._capture_status: Optional[AsyncStatus] = None
-        self._start_status: Optional[AsyncStatus] = None
-        self.set_readable_signals(config=[self.drv.acquire_time])
-        super().__init__(name)
-
-    @AsyncStatus.wrap
-    async def stage(self) -> None:
-        # Make a new resource for the new HDF file we're going to open
-        self._resource = _HDFResource()
-        await asyncio.gather(
-            self.drv.wait_for_plugins.set(True),
-            self.hdf.lazy_open.set(True),
-            self.hdf.swmr_mode.set(True),
-            self.hdf.file_path.set(str(await self._dp.get_directory())),
-            self.hdf.file_name.set(f"{self.name}-{new_uid()}"),
-            self.hdf.file_template.set("%s/%s.h5"),
-            # Go forever
-            self.hdf.num_capture.set(0),
-            self.hdf.file_write_mode.set(FileWriteMode.stream),
-        )
-        # Wait for it to start, stashing the status that tells us when it finishes
-        self._capture_status = await set_and_wait_for_value(self.hdf.capture, True)
-        await super().stage()
-
-    async def describe(self) -> Dict[str, Descriptor]:
-        datakeys = await super().describe()
-        # Insert a descriptor for the HDF resource, this will not appear
-        # in read() as it describes StreamResource outputs only
-        datakeys[self.name] = Descriptor(
-            source=self.hdf.full_file_name.source,
-            shape=await asyncio.gather(
-                self.drv.array_size_y.get_value(),
-                self.drv.array_size_x.get_value(),
-            ),
-            dtype="array",
-            external="STREAM:",
-        )
-        return datakeys
-
-    # For step scan, take a single frame
-    @AsyncStatus.wrap
-    async def trigger(self):
-        await self.drv.image_mode.set(ImageMode.single)
-        frame_timeout = DEFAULT_TIMEOUT + await self.drv.acquire_time.get_value()
-        await self.drv.acquire.set(1, timeout=frame_timeout)
-        await self._resource.flush_and_publish(self.hdf)
-
-    def collect_asset_docs(self) -> Iterator[Asset]:
-        while self._resource.asset_docs:
-            yield self._resource.asset_docs.popleft()
-
-    # For flyscan, take the number of frames we wanted
-    @AsyncStatus.wrap
-    async def kickoff(self) -> None:
-        await self.drv.image_mode.set(ImageMode.multiple)
-        # Wait for it to start, stashing the status that tells us when it finishes
-        self._start_status = await set_and_wait_for_value(self.drv.acquire, True)
-
-    # Do the same thing for flyscans and step scans
-    async def describe_collect(self) -> Dict[str, Dict[str, Descriptor]]:
-        return {self.name: await self.describe()}
-
-    def collect(self) -> Iterator[PartialEvent]:
-        yield from iter([])
-
-    @AsyncStatus.wrap
-    async def complete(self) -> None:
-        done: Sized = ()
-        while not done:
-            assert self._start_status, "Kickoff not run"
-            done, _ = await asyncio.wait(
-                (self._start_status.task,), timeout=FLUSH_PERIOD
-            )
-            await self._resource.flush_and_publish(self.hdf)
-
-    @AsyncStatus.wrap
-    async def unstage(self) -> None:
-        # Already done a caput callback in _capture_status, so can't do one here
-        await self.hdf.capture.set(False, wait=False)
-        assert self._capture_status, "Stage not run"
-        await self._capture_status
-        await super().unstage()

ophyd_async/epics/areadetector/nd_file_hdf.py

@@ -1,22 +0,0 @@
-from ophyd_async.core import Device
-
-from ..signal.signal import epics_signal_rw
-from .utils import FileWriteMode, ad_r, ad_rw
-
-
-class NDFileHDF(Device):
-    def __init__(self, prefix: str) -> None:
-        # Define some signals
-        self.file_path = ad_rw(str, prefix + "FilePath")
-        self.file_name = ad_rw(str, prefix + "FileName")
-        self.file_template = ad_rw(str, prefix + "FileTemplate")
-        self.full_file_name = ad_r(str, prefix + "FullFileName")
-        self.file_write_mode = ad_rw(FileWriteMode, prefix + "FileWriteMode")
-        self.num_capture = ad_rw(int, prefix + "NumCapture")
-        self.num_captured = ad_r(int, prefix + "NumCaptured")
-        self.swmr_mode = ad_rw(bool, prefix + "SWMRMode")
-        self.lazy_open = ad_rw(bool, prefix + "LazyOpen")
-        self.capture = ad_rw(bool, prefix + "Capture")
-        self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
-        self.array_size0 = ad_r(int, prefix + "ArraySize0")
-        self.array_size1 = ad_r(int, prefix + "ArraySize1")

ophyd_async/epics/areadetector/nd_plugin.py

@@ -1,13 +0,0 @@
-from ophyd_async.core import Device
-
-from .utils import ad_r
-
-
-class NDPlugin(Device):
-    pass
-
-
-class NDPluginStats(NDPlugin):
-    def __init__(self, prefix: str) -> None:
-        # Define some signals
-        self.unique_id = ad_r(int, prefix + "UniqueId")

ophyd_async/epics/signal/pvi_get.py

@@ -1,22 +0,0 @@
-from typing import Dict, TypedDict
-
-from p4p.client.asyncio import Context
-
-
-class PVIEntry(TypedDict, total=False):
-    d: str
-    r: str
-    rw: str
-    w: str
-    x: str
-
-
-async def pvi_get(pv: str, ctxt: Context, timeout: float = 5.0) -> Dict[str, PVIEntry]:
-    pv_info = ctxt.get(pv, timeout=timeout).get("pvi").todict()
-
-    result = {}
-
-    for attr_name, attr_info in pv_info.items():
-        result[attr_name] = PVIEntry(**attr_info)  # type: ignore
-
-    return result