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

ophyd_async/epics/core/_util.py

@@ -13,12 +13,12 @@ from ophyd_async.core import (
 
 
 def get_pv_basename_and_field(pv: str) -> tuple[str, str | None]:
-    """Simple utility function for extracting base pv name without field"""
-
+    """Split PV into record name and field."""
     if "." in pv:
-        return (pv.split(".", -1)[0], pv.split(".", -1)[1])
+        record, field = pv.split(".", maxsplit=1)
     else:
-        return (pv, None)
+        record, field = pv, None
+    return (record, field)
 
 
 def get_supported_values(
@@ -47,7 +47,7 @@ def get_supported_values(
 
 
 def format_datatype(datatype: Any) -> str:
-    if get_origin(datatype) is np.ndarray and get_args(datatype)[0] == tuple[int]:
+    if get_origin(datatype) is np.ndarray and get_args(datatype):
         dtype = get_dtype(datatype)
         return f"Array1D[np.{dtype.name}]"
     elif get_origin(datatype) is Sequence:

ophyd_async/epics/demo/__init__.py

@@ -1,54 +1,16 @@
-"""Demo EPICS Devices for the tutorial"""
+"""Demo EPICS Devices for the tutorial."""
 
-import atexit
-import random
-import string
-import subprocess
-import sys
-from pathlib import Path
-
-from ._mover import Mover, SampleStage
-from ._sensor import EnergyMode, Sensor, SensorGroup
+from ._ioc import start_ioc_subprocess
+from ._motor import DemoMotor
+from ._point_detector import DemoPointDetector
+from ._point_detector_channel import DemoPointDetectorChannel, EnergyMode
+from ._stage import DemoStage
 
 __all__ = [
-    "Mover",
-    "SampleStage",
+    "DemoMotor",
+    "DemoStage",
     "EnergyMode",
-    "Sensor",
-    "SensorGroup",
+    "DemoPointDetectorChannel",
+    "DemoPointDetector",
+    "start_ioc_subprocess",
 ]
-
-
-def start_ioc_subprocess() -> str:
-    """Start an IOC subprocess with EPICS database for sample stage and sensor
-    with the same pv prefix
-    """
-
-    pv_prefix = "".join(random.choice(string.ascii_uppercase) for _ in range(12)) + ":"
-    here = Path(__file__).absolute().parent
-    args = [sys.executable, "-m", "epicscorelibs.ioc"]
-
-    # Create standalone sensor
-    args += ["-m", f"P={pv_prefix}"]
-    args += ["-d", str(here / "sensor.db")]
-
-    # Create sensor group
-    for suffix in ["1", "2", "3"]:
-        args += ["-m", f"P={pv_prefix}{suffix}:"]
-        args += ["-d", str(here / "sensor.db")]
-
-    # Create X and Y motors
-    for suffix in ["X", "Y"]:
-        args += ["-m", f"P={pv_prefix}{suffix}:"]
-        args += ["-d", str(here / "mover.db")]
-
-    # Start IOC
-    process = subprocess.Popen(
-        args,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        universal_newlines=True,
-    )
-    atexit.register(process.communicate, "exit")
-    return pv_prefix

ophyd_async/epics/demo/__main__.py

@@ -0,0 +1,31 @@
+"""Used for tutorial `Implementing Devices`."""
+
+# Import bluesky and ophyd
+import bluesky.plan_stubs as bps  # noqa: F401
+import bluesky.plans as bp  # noqa: F401
+from bluesky.callbacks.best_effort import BestEffortCallback
+from bluesky.run_engine import RunEngine, autoawait_in_bluesky_event_loop
+
+from ophyd_async.core import init_devices
+from ophyd_async.epics import demo, testing
+
+# Create a run engine and make ipython use it for `await` commands
+RE = RunEngine(call_returns_result=True)
+autoawait_in_bluesky_event_loop()
+
+# Add a callback for plotting
+bec = BestEffortCallback()
+RE.subscribe(bec)
+
+# Start IOC with demo pvs in subprocess
+prefix = testing.generate_random_pv_prefix()
+ioc = demo.start_ioc_subprocess(prefix, num_channels=3)
+
+# All Devices created within this block will be
+# connected and named at the end of the with block
+with init_devices():
+    # Create a sample stage with X and Y motors
+    stage = demo.DemoStage(f"{prefix}STAGE:")
+    # Create a multi channel counter with the same number
+    # of counters as the IOC
+    pdet = demo.DemoPointDetector(f"{prefix}DET:", num_channels=3)

ophyd_async/epics/demo/_ioc.py

@@ -0,0 +1,32 @@
+import atexit
+from pathlib import Path
+
+from ophyd_async.epics.testing import TestingIOC
+
+HERE = Path(__file__).absolute().parent
+
+
+def start_ioc_subprocess(prefix: str, num_channels: int) -> TestingIOC:
+    """Start an IOC subprocess for sample stage and sensor.
+
+    :param prefix: The prefix for the IOC PVs.
+    :param num_channels: The number of point detector channels to create.
+    """
+    ioc = TestingIOC()
+    # Create X and Y motors
+    for suffix in ["X", "Y"]:
+        ioc.add_database(HERE / "motor.db", P=f"{prefix}STAGE:{suffix}:")
+    # Create a multichannel counter with num_counters
+    ioc.add_database(HERE / "point_detector.db", P=f"{prefix}DET:")
+    for i in range(1, num_channels + 1):
+        ioc.add_database(
+            HERE / "point_detector_channel.db",
+            P=f"{prefix}DET:",
+            CHANNEL=str(i),
+            X=f"{prefix}STAGE:X:",
+            Y=f"{prefix}STAGE:Y:",
+        )
+    # Start IOC and register it to be stopped at exit
+    ioc.start()
+    atexit.register(ioc.stop)
+    return ioc

ophyd_async/epics/demo/_motor.py

@@ -0,0 +1,82 @@
+import asyncio
+from typing import Annotated as A
+
+import numpy as np
+from bluesky.protocols import Movable, Stoppable
+
+from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
+    DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StandardReadable,
+    WatchableAsyncStatus,
+    WatcherUpdate,
+    observe_value,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
+
+
+class DemoMotor(EpicsDevice, StandardReadable, Movable, Stoppable):
+    """A demo movable that moves based on velocity."""
+
+    # Whether set() should complete successfully or not
+    _set_success = True
+    # Define some signals
+    readback: A[SignalR[float], PvSuffix("Readback"), Format.HINTED_SIGNAL]
+    velocity: A[SignalRW[float], PvSuffix("Velocity"), Format.CONFIG_SIGNAL]
+    units: A[SignalR[str], PvSuffix("Readback.EGU"), Format.CONFIG_SIGNAL]
+    setpoint: A[SignalRW[float], PvSuffix("Setpoint")]
+    precision: A[SignalR[int], PvSuffix("Readback.PREC")]
+    # If a signal name clashes with a bluesky verb add _ to the attribute name
+    stop_: A[SignalX, PvSuffix("Stop.PROC")]
+
+    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(  # type: ignore
+        self, new_position: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT
+    ):
+        # The move should complete successfully unless stop(success=False) is called
+        self._set_success = True
+        # Get some variables for the progress bar reporting
+        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 not supplied, calculate a suitable timeout for the move
+        if timeout == CALCULATE_TIMEOUT:
+            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
+        # Wait for the value to set, but don't wait for put completion callback
+        await self.setpoint.set(new_position, wait=False)
+        # Observe the readback Signal, and on each new position...
+        async for current_position in observe_value(
+            self.readback, done_timeout=timeout
+        ):
+            # Emit a progress bar update
+            yield WatcherUpdate(
+                current=current_position,
+                initial=old_position,
+                target=new_position,
+                name=self.name,
+                unit=units,
+                precision=precision,
+            )
+            # If we are at the desired position the break
+            if np.isclose(current_position, new_position):
+                break
+        # If we were told to stop and report an error then do so
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
+
+    async def stop(self, success=True):
+        self._set_success = success
+        await self.stop_.trigger()

ophyd_async/epics/demo/_point_detector.py

@@ -0,0 +1,42 @@
+from typing import Annotated as A
+
+from bluesky.protocols import Triggerable
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DeviceVector,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StandardReadable,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
+
+from ._point_detector_channel import DemoPointDetectorChannel
+
+
+class DemoPointDetector(StandardReadable, EpicsDevice, Triggerable):
+    """A demo detector that produces a point values based on X and Y motors."""
+
+    acquire_time: A[SignalRW[float], PvSuffix("AcquireTime"), Format.CONFIG_SIGNAL]
+    start: A[SignalX, PvSuffix("Start.PROC")]
+    acquiring: A[SignalR[bool], PvSuffix("Acquiring")]
+    reset: A[SignalX, PvSuffix("Reset.PROC")]
+
+    def __init__(self, prefix: str, num_channels: int = 3, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.channel = DeviceVector(
+                {
+                    i: DemoPointDetectorChannel(f"{prefix}{i}:")
+                    for i in range(1, num_channels + 1)
+                }
+            )
+        super().__init__(prefix=prefix, name=name)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        await self.reset.trigger()
+        timeout = await self.acquire_time.get_value() + DEFAULT_TIMEOUT
+        await self.start.trigger(timeout=timeout)

ophyd_async/epics/demo/_point_detector_channel.py

@@ -0,0 +1,22 @@
+from typing import Annotated as A
+
+from ophyd_async.core import 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 `DemoPointDetectorChannel`."""
+
+    LOW = "Low Energy"
+    """Low energy mode"""
+
+    HIGH = "High Energy"
+    """High energy mode"""
+
+
+class DemoPointDetectorChannel(StandardReadable, EpicsDevice):
+    """A channel for `DemoPointDetector` with int value based on X and Y Motors."""
+
+    value: A[SignalR[int], PvSuffix("Value"), Format.HINTED_UNCACHED_SIGNAL]
+    mode: A[SignalRW[EnergyMode], PvSuffix("Mode"), Format.CONFIG_SIGNAL]

ophyd_async/epics/demo/_stage.py

@@ -0,0 +1,15 @@
+from ophyd_async.core import StandardReadable
+
+from ._motor import DemoMotor
+
+
+class DemoStage(StandardReadable):
+    """A simulated sample stage with X and Y movables."""
+
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some child Devices
+        with self.add_children_as_readables():
+            self.x = DemoMotor(prefix + "X:")
+            self.y = DemoMotor(prefix + "Y:")
+        # Set name of device and child devices
+        super().__init__(name=name)

ophyd_async/epics/demo/{mover.db → motor.db}

@@ -10,7 +10,8 @@ record(ao, "$(P)Velocity") {
     field(PREC, "$(PREC=3)")
     field(PINI, "YES")
     field(EGU,  "$(EGU=mm)/s")
-    field(VAL,  "$(VELO=100)")
+    field(VAL,  "$(VELO=1)")
+    field(DRVL, "0")
 }
 
 record(calc, "$(P)VelocityDiv") {

ophyd_async/epics/demo/point_detector.db

@@ -0,0 +1,59 @@
+record(ao, "$(P)AcquireTime") {
+    field(DESC, "Time to acquire for")
+    field(VAL, "0.1")
+    field(OUT, "$(P)Start.DLY2")
+    field(PINI, "YES")
+}
+
+record(seq, "$(P)Start") {
+    field(DESC, "Start sequence")
+    # Grab the start time
+    field(LNK0, "$(P)StartTime.PROC")
+    # Set it to be acquiring
+    field(LNK1, "$(P)Acquiring PP")
+    field(DO1, "1")
+    # Set it back to idle
+    field(LNK2, "$(P)Acquiring PP")
+    field(DO2, "0")
+    # Set the elapsed time to the full acquire time
+    field(LNK3, "$(P)Elapsed PP")
+    field(DOL3, "$(P)AcquireTime")
+}
+
+record(ai, "$(P)StartTime") {
+    field(DTYP, "Soft Timestamp")
+}
+
+record(bi, "$(P)Acquiring") {
+    field(DESC, "Currently acquiring")
+    field(ZNAM, "Idle")
+    field(ONAM, "Acquiring")
+    field(PINI, "YES")
+}
+
+record(ai, "$(P)CurrentTime") {
+    field(DTYP, "Soft Timestamp")
+}
+
+record(calcout, "$(P)Process") {
+    field(DESC, "Process elapsed time if acquiring")
+    field(INPA, "$(P)StartTime")
+    field(INPB, "$(P)CurrentTime PP")
+    field(SCAN, ".1 second")
+    field(CALC, "B-A")
+    field(OUT, "$(P)Elapsed PP")
+    field(SDIS, "$(P)Acquiring")
+    field(DISV, "0")
+}
+
+record(ai, "$(P)Elapsed") {
+    field(DESC, "Elapsed time")
+    field(EGU,  "s")
+    field(PREC, "1")
+    field(PINI, "YES")
+}
+
+record(calcout, "$(P)Reset") {
+    field(OUT, "$(P)Elapsed PP")
+    field(CALC, "0")
+}

ophyd_async/epics/demo/point_detector_channel.db

@@ -0,0 +1,21 @@
+record(mbbo, "$(P)$(CHANNEL):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)$(CHANNEL):Value") {
+    field(DESC, "Sensor value simulated from X and Y")
+    field(INPA,  "$(X)Readback")
+    field(INPB,  "$(Y)Readback")
+    field(INPC,  "$(CHANNEL)")
+    field(INPD,  "$(P)$(CHANNEL):Mode.RVAL")
+    field(INPE,  "$(P)Elapsed CP")
+    field(CALC, "FLOOR((SIN(A)**C+COS(A*B+D)+2)*2500*E)")
+    field(EGU,  "cts")
+    field(PREC, "0")
+}

ophyd_async/epics/eiger/_eiger.py

@@ -12,9 +12,7 @@ class EigerTriggerInfo(TriggerInfo):
 
 
 class EigerDetector(StandardDetector):
-    """
-    Ophyd-async implementation of an Eiger Detector.
-    """
+    """Ophyd-async implementation of an Eiger Detector."""
 
     _controller: EigerController
     _writer: Odin

ophyd_async/epics/eiger/_eiger_controller.py

@@ -2,6 +2,7 @@ import asyncio
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
+    AsyncStatus,
     DetectorController,
     DetectorTrigger,
     TriggerInfo,
@@ -19,19 +20,24 @@ EIGER_TRIGGER_MODE_MAP = {
 
 
 class EigerController(DetectorController):
+    """Controller for the Eiger detector."""
+
     def __init__(
         self,
         driver: EigerDriverIO,
     ) -> None:
         self._drv = driver
+        self._arm_status: AsyncStatus | None = None
 
     def get_deadtime(self, exposure: float | None) -> float:
         # See https://media.dectris.com/filer_public/30/14/3014704e-5f3b-43ba-8ccf-8ef720e60d2a/240202_usermanual_eiger2.pdf
         return 0.0001
 
     async def set_energy(self, energy: float, tolerance: float = 0.1):
-        """Changing photon energy takes some time so only do so if the current energy is
-        outside the tolerance."""
+        """Change photon energy if outside tolerance.
+
+        It takes some time so don't do it unless it is outside tolerance.
+        """
         current_energy = await self._drv.photon_energy.get_value()
         if abs(current_energy - energy) > tolerance:
             await self._drv.photon_energy.set(energy)
@@ -54,7 +60,7 @@ class EigerController(DetectorController):
 
     async def arm(self):
         # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
-        self._arm_status = set_and_wait_for_other_value(
+        self._arm_status = await set_and_wait_for_other_value(
             self._drv.arm,
             1,
             self._drv.state,
@@ -64,8 +70,9 @@ class EigerController(DetectorController):
         )
 
     async def wait_for_idle(self):
-        if self._arm_status:
+        if self._arm_status and not self._arm_status.done:
             await self._arm_status
+        self._arm_status = None
 
     async def disarm(self):
         await self._drv.disarm.set(1)

ophyd_async/epics/eiger/_eiger_io.py

@@ -9,6 +9,8 @@ class EigerTriggerMode(StrictEnum):
 
 
 class EigerDriverIO(Device):
+    """Contains signals for handling IO on the Eiger detector."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         self.bit_depth = epics_signal_r(int, f"{prefix}BitDepthReadout")
         self.stale_parameters = epics_signal_r(bool, f"{prefix}StaleParameters")

ophyd_async/epics/eiger/_odin_io.py

@@ -5,7 +5,6 @@ from bluesky.protocols import StreamAsset
 from event_model import DataKey
 
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
     DetectorWriter,
     Device,
     DeviceVector,
@@ -110,7 +109,7 @@ class OdinWriter(DetectorWriter):
         }
 
     async def observe_indices_written(
-        self, timeout=DEFAULT_TIMEOUT
+        self, timeout: float
     ) -> AsyncGenerator[int, None]:
         async for num_captured in observe_value(self._drv.num_captured, timeout):
             yield num_captured