ophyd-async 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

ophyd_async/epics/{areadetector/drivers/kinetix_driver.py → adkinetix/_kinetix_io.py}

@@ -1,8 +1,7 @@
 from enum import Enum
 
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
-
-from .ad_base import ADBase
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_rw_rbv
 
 
 class KinetixTriggerMode(str, Enum):
@@ -15,13 +14,18 @@ class KinetixReadoutMode(str, Enum):
     sensitivity = 1
     speed = 2
     dynamic_range = 3
+    sub_electron = 4
+
 
+class KinetixDriverIO(adcore.ADBaseIO):
+    """This mirrors the interface provided by ADKinetix/db/ADKinetix.template."""
 
-class KinetixDriver(ADBase):
     def __init__(self, prefix: str, name: str = "") -> None:
         # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
         self.trigger_mode = epics_signal_rw_rbv(
             KinetixTriggerMode, prefix + "TriggerMode"
         )
-        self.mode = epics_signal_rw_rbv(KinetixReadoutMode, prefix + "ReadoutPortIdx")
+        self.readout_port_idx = epics_signal_rw_rbv(
+            KinetixReadoutMode, prefix + "ReadoutPortIdx"
+        )
         super().__init__(prefix, name)

ophyd_async/epics/adpilatus/__init__.py

@@ -0,0 +1,11 @@
+from ._pilatus import PilatusDetector, PilatusReadoutTime
+from ._pilatus_controller import PilatusController
+from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
+
+__all__ = [
+    "PilatusDetector",
+    "PilatusReadoutTime",
+    "PilatusController",
+    "PilatusDriverIO",
+    "PilatusTriggerMode",
+]

ophyd_async/epics/{areadetector/pilatus.py → adpilatus/_pilatus.py}

@@ -2,15 +2,11 @@ from enum import Enum
 
 from bluesky.protocols import Hints
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core.detector import StandardDetector
-from ophyd_async.epics.areadetector.controllers.pilatus_controller import (
-    PilatusController,
-)
-from ophyd_async.epics.areadetector.drivers.ad_base import ADBaseShapeProvider
-from ophyd_async.epics.areadetector.drivers.pilatus_driver import PilatusDriver
-from ophyd_async.epics.areadetector.writers.hdf_writer import HDFWriter
-from ophyd_async.epics.areadetector.writers.nd_file_hdf import NDFileHDF
+from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.epics import adcore
+
+from ._pilatus_controller import PilatusController
+from ._pilatus_io import PilatusDriverIO
 
 
 #: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
@@ -31,7 +27,7 @@ class PilatusDetector(StandardDetector):
     """A Pilatus StandardDetector writing HDF files"""
 
     _controller: PilatusController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
@@ -42,16 +38,16 @@ class PilatusDetector(StandardDetector):
         hdf_suffix: str = "HDF1:",
         name: str = "",
     ):
-        self.drv = PilatusDriver(prefix + drv_suffix)
-        self.hdf = NDFileHDF(prefix + hdf_suffix)
+        self.drv = PilatusDriverIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             PilatusController(self.drv, readout_time=readout_time.value),
-            HDFWriter(
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/{areadetector/controllers/pilatus_controller.py → adpilatus/_pilatus_controller.py}

@@ -1,18 +1,16 @@
 import asyncio
 from typing import Optional
 
-from ophyd_async.core import DEFAULT_TIMEOUT, wait_for_value
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.detector import DetectorControl, DetectorTrigger
-from ophyd_async.epics.areadetector.drivers.ad_base import (
-    set_exposure_time_and_acquire_period_if_supplied,
-    start_acquiring_driver_and_ensure_status,
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    wait_for_value,
 )
-from ophyd_async.epics.areadetector.drivers.pilatus_driver import (
-    PilatusDriver,
-    PilatusTriggerMode,
-)
-from ophyd_async.epics.areadetector.utils import ImageMode, stop_busy_record
+from ophyd_async.epics import adcore
+
+from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 
 class PilatusController(DetectorControl):
@@ -24,7 +22,7 @@ class PilatusController(DetectorControl):
 
     def __init__(
         self,
-        driver: PilatusDriver,
+        driver: PilatusDriverIO,
         readout_time: float,
     ) -> None:
         self._drv = driver
@@ -40,23 +38,23 @@ class PilatusController(DetectorControl):
         exposure: Optional[float] = None,
     ) -> AsyncStatus:
         if exposure is not None:
-            await set_exposure_time_and_acquire_period_if_supplied(
+            await adcore.set_exposure_time_and_acquire_period_if_supplied(
                 self, self._drv, exposure
             )
         await asyncio.gather(
             self._drv.trigger_mode.set(self._get_trigger_mode(trigger)),
             self._drv.num_images.set(999_999 if num == 0 else num),
-            self._drv.image_mode.set(ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
 
         # Standard arm the detector and wait for the acquire PV to be True
-        idle_status = await start_acquiring_driver_and_ensure_status(self._drv)
+        idle_status = await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
         # The pilatus has an additional PV that goes True when the camserver
         # is actually ready. Should wait for that too or we risk dropping
         # a frame
         await wait_for_value(
-            self._drv.armed_for_triggers,
+            self._drv.armed,
             True,
             timeout=DEFAULT_TIMEOUT,
         )
@@ -74,4 +72,4 @@ class PilatusController(DetectorControl):
         return cls._supported_trigger_types[trigger]
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/{areadetector/drivers/pilatus_driver.py → adpilatus/_pilatus_io.py}

@@ -1,7 +1,7 @@
 from enum import Enum
 
-from ...signal import epics_signal_r, epics_signal_rw_rbv
-from .ad_base import ADBase
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv
 
 
 class PilatusTriggerMode(str, Enum):
@@ -12,10 +12,12 @@ class PilatusTriggerMode(str, Enum):
     alignment = "Alignment"
 
 
-class PilatusDriver(ADBase):
+class PilatusDriverIO(adcore.ADBaseIO):
+    """This mirrors the interface provided by ADPilatus/db/pilatus.template."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         self.trigger_mode = epics_signal_rw_rbv(
             PilatusTriggerMode, prefix + "TriggerMode"
         )
-        self.armed_for_triggers = epics_signal_r(bool, prefix + "Armed")
+        self.armed = epics_signal_r(bool, prefix + "Armed")
         super().__init__(prefix, name)

ophyd_async/epics/adsimdetector/__init__.py

@@ -0,0 +1,7 @@
+from ._sim import SimDetector
+from ._sim_controller import SimController
+
+__all__ = [
+    "SimDetector",
+    "SimController",
+]

ophyd_async/epics/{demo/demo_ad_sim_detector.py → adsimdetector/_sim.py}

@@ -1,20 +1,19 @@
 from typing import Sequence
 
 from ophyd_async.core import PathProvider, SignalR, StandardDetector
+from ophyd_async.epics import adcore
 
-from ..areadetector.controllers import ADSimController
-from ..areadetector.drivers import ADBase, ADBaseShapeProvider
-from ..areadetector.writers import HDFWriter, NDFileHDF
+from ._sim_controller import SimController
 
 
-class DemoADSimDetector(StandardDetector):
-    _controller: ADSimController
-    _writer: HDFWriter
+class SimDetector(StandardDetector):
+    _controller: SimController
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
-        drv: ADBase,
-        hdf: NDFileHDF,
+        drv: adcore.ADBaseIO,
+        hdf: adcore.NDFileHDFIO,
         path_provider: PathProvider,
         name: str = "",
         config_sigs: Sequence[SignalR] = (),
@@ -23,12 +22,12 @@ class DemoADSimDetector(StandardDetector):
         self.hdf = hdf
 
         super().__init__(
-            ADSimController(self.drv),
-            HDFWriter(
+            SimController(self.drv),
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=config_sigs,
             name=name,

ophyd_async/epics/{areadetector/controllers/ad_sim_controller.py → adsimdetector/_sim_controller.py}

@@ -7,20 +7,14 @@ from ophyd_async.core import (
     DetectorControl,
     DetectorTrigger,
 )
-
-from ..drivers.ad_base import (
-    DEFAULT_GOOD_STATES,
-    ADBase,
-    DetectorState,
-    ImageMode,
-    start_acquiring_driver_and_ensure_status,
-)
-from ..utils import stop_busy_record
+from ophyd_async.epics import adcore
 
 
-class ADSimController(DetectorControl):
+class SimController(DetectorControl):
     def __init__(
-        self, driver: ADBase, good_states: Set[DetectorState] = set(DEFAULT_GOOD_STATES)
+        self,
+        driver: adcore.ADBaseIO,
+        good_states: Set[adcore.DetectorState] = set(adcore.DEFAULT_GOOD_STATES),
     ) -> None:
         self.driver = driver
         self.good_states = good_states
@@ -40,13 +34,13 @@ class ADSimController(DetectorControl):
         frame_timeout = DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         await asyncio.gather(
             self.driver.num_images.set(num),
-            self.driver.image_mode.set(ImageMode.multiple),
+            self.driver.image_mode.set(adcore.ImageMode.multiple),
         )
-        return await start_acquiring_driver_and_ensure_status(
+        return await adcore.start_acquiring_driver_and_ensure_status(
             self.driver, good_states=self.good_states, timeout=frame_timeout
         )
 
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await stop_busy_record(self.driver.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self.driver.acquire, False, timeout=1)

ophyd_async/epics/advimba/__init__.py

@@ -0,0 +1,9 @@
+from ._vimba import VimbaDetector
+from ._vimba_controller import VimbaController
+from ._vimba_io import VimbaDriverIO
+
+__all__ = [
+    "VimbaDetector",
+    "VimbaController",
+    "VimbaDriverIO",
+]

ophyd_async/epics/{areadetector/vimba.py → advimba/_vimba.py}

@@ -1,10 +1,10 @@
 from bluesky.protocols import HasHints, Hints
 
 from ophyd_async.core import PathProvider, 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
+from ophyd_async.epics import adcore
+
+from ._vimba_controller import VimbaController
+from ._vimba_io import VimbaDriverIO
 
 
 class VimbaDetector(StandardDetector, HasHints):
@@ -13,7 +13,7 @@ class VimbaDetector(StandardDetector, HasHints):
     """
 
     _controller: VimbaController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
@@ -23,16 +23,16 @@ class VimbaDetector(StandardDetector, HasHints):
         hdf_suffix="HDF1:",
         name="",
     ):
-        self.drv = VimbaDriver(prefix + drv_suffix)
-        self.hdf = NDFileHDF(prefix + hdf_suffix)
+        self.drv = VimbaDriverIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             VimbaController(self.drv),
-            HDFWriter(
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/{areadetector/controllers/vimba_controller.py → advimba/_vimba_controller.py}

@@ -2,17 +2,9 @@ import asyncio
 from typing import Optional
 
 from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
-from ophyd_async.epics.areadetector.drivers.ad_base import (
-    start_acquiring_driver_and_ensure_status,
-)
+from ophyd_async.epics import adcore
 
-from ..drivers.vimba_driver import (
-    VimbaDriver,
-    VimbaExposeOutMode,
-    VimbaOnOff,
-    VimbaTriggerSource,
-)
-from ..utils import ImageMode, stop_busy_record
+from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
 
 TRIGGER_MODE = {
     DetectorTrigger.internal: VimbaOnOff.off,
@@ -32,7 +24,7 @@ EXPOSE_OUT_MODE = {
 class VimbaController(DetectorControl):
     def __init__(
         self,
-        driver: VimbaDriver,
+        driver: VimbaDriverIO,
     ) -> None:
         self._drv = driver
 
@@ -47,9 +39,9 @@ class VimbaController(DetectorControl):
     ) -> AsyncStatus:
         await asyncio.gather(
             self._drv.trigger_mode.set(TRIGGER_MODE[trigger]),
-            self._drv.expose_mode.set(EXPOSE_OUT_MODE[trigger]),
+            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger]),
             self._drv.num_images.set(num),
-            self._drv.image_mode.set(ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
         if exposure is not None and trigger not in [
             DetectorTrigger.variable_gate,
@@ -57,10 +49,10 @@ class VimbaController(DetectorControl):
         ]:
             await self._drv.acquire_time.set(exposure)
         if trigger != DetectorTrigger.internal:
-            self._drv.trig_source.set(VimbaTriggerSource.line1)
+            self._drv.trigger_source.set(VimbaTriggerSource.line1)
         else:
-            self._drv.trig_source.set(VimbaTriggerSource.freerun)
-        return await start_acquiring_driver_and_ensure_status(self._drv)
+            self._drv.trigger_source.set(VimbaTriggerSource.freerun)
+        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/{areadetector/drivers/vimba_driver.py → advimba/_vimba_io.py}

@@ -1,8 +1,7 @@
 from enum import Enum
 
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
-
-from .ad_base import ADBase
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_rw_rbv
 
 
 class VimbaPixelFormat(str, Enum):
@@ -46,18 +45,22 @@ class VimbaExposeOutMode(str, Enum):
     trigger_width = "TriggerWidth"  # Expose for length of high signal
 
 
-class VimbaDriver(ADBase):
+class VimbaDriverIO(adcore.ADBaseIO):
+    """This mirrors the interface provided by ADVimba/db/vimba.template."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
-        self.convert_format = epics_signal_rw_rbv(
+        self.convert_pixel_format = epics_signal_rw_rbv(
             VimbaConvertFormat, prefix + "ConvertPixelFormat"
         )  # Pixel format of data outputted to AD
-        self.trig_source = epics_signal_rw_rbv(
+        self.trigger_source = epics_signal_rw_rbv(
             VimbaTriggerSource, prefix + "TriggerSource"
         )
         self.trigger_mode = epics_signal_rw_rbv(VimbaOnOff, prefix + "TriggerMode")
-        self.overlap = epics_signal_rw_rbv(VimbaOverlap, prefix + "TriggerOverlap")
-        self.expose_mode = epics_signal_rw_rbv(
+        self.trigger_overlap = epics_signal_rw_rbv(
+            VimbaOverlap, prefix + "TriggerOverlap"
+        )
+        self.exposure_mode = epics_signal_rw_rbv(
             VimbaExposeOutMode, prefix + "ExposureMode"
         )
         super().__init__(prefix, name)

ophyd_async/epics/demo/__init__.py

@@ -1,145 +1,22 @@
 """Demo EPICS Devices for the tutorial"""
 
-import asyncio
 import atexit
 import random
 import string
 import subprocess
 import sys
-from enum import Enum
 from pathlib import Path
 
-import numpy as np
-from bluesky.protocols import Movable, Stoppable
+from ._mover import Mover, SampleStage
+from ._sensor import EnergyMode, Sensor, SensorGroup
 
-from ophyd_async.core import (
-    ConfigSignal,
-    Device,
-    DeviceVector,
-    HintedSignal,
-    StandardReadable,
-    WatchableAsyncStatus,
-    observe_value,
-)
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.utils import (
-    DEFAULT_TIMEOUT,
-    CalculatableTimeout,
-    CalculateTimeout,
-    WatcherUpdate,
-)
-
-from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
-
-
-class EnergyMode(str, Enum):
-    """Energy mode for `Sensor`"""
-
-    #: Low energy mode
-    low = "Low Energy"
-    #: High energy mode
-    high = "High Energy"
-
-
-class Sensor(StandardReadable):
-    """A demo sensor that produces a scalar value based on X and Y Movers"""
-
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        with self.add_children_as_readables(HintedSignal):
-            self.value = epics_signal_r(float, prefix + "Value")
-        with self.add_children_as_readables(ConfigSignal):
-            self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
-
-        super().__init__(name=name)
-
-
-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)
-
-
-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(HintedSignal):
-            self.readback = epics_signal_r(float, prefix + "Readback")
-        with self.add_children_as_readables(ConfigSignal):
-            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):
-        super().set_name(name)
-        # Readback should be named the same as its parent in read()
-        self.readback.set_name(name)
-
-    @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
-        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 is CalculateTimeout:
-            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)
+__all__ = [
+    "Mover",
+    "SampleStage",
+    "EnergyMode",
+    "Sensor",
+    "SensorGroup",
+]
 
 
 def start_ioc_subprocess() -> str: