ophyd-async 0.3a4__py3-none-any.whl → 0.3a5__py3-none-any.whl

ophyd_async/epics/areadetector/drivers/aravis_driver.py

@@ -1,8 +1,8 @@
 from enum import Enum
-from typing import Callable, Dict, Literal, Optional, Tuple
+from typing import Literal
 
 from ophyd_async.epics.areadetector.drivers import ADBase
-from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw_rbv
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
 
 
 class AravisTriggerMode(str, Enum):
@@ -22,113 +22,6 @@ class AravisTriggerMode(str, Enum):
 AravisTriggerSource = Literal["Freerun", "Line1", "Line2", "Line3", "Line4"]
 
 
-def _reverse_lookup(
-    model_deadtimes: Dict[float, Tuple[str, ...]],
-) -> Callable[[str], float]:
-    def inner(pixel_format: str, model_name: str) -> float:
-        for deadtime, pixel_formats in model_deadtimes.items():
-            if pixel_format in pixel_formats:
-                return deadtime
-        raise ValueError(
-            f"Model {model_name} does not have a defined deadtime "
-            f"for pixel format {pixel_format}"
-        )
-
-    return inner
-
-
-_deadtimes: Dict[str, Callable[[str, str], float]] = {
-    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/Manta/techman/Manta_TechMan.pdf retrieved 2024-04-05  # noqa: E501
-    "Manta G-125": lambda _, __: 63e-6,
-    "Manta G-145": lambda _, __: 106e-6,
-    "Manta G-235": _reverse_lookup(
-        {
-            118e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            256e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            390e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-    "Manta G-895": _reverse_lookup(
-        {
-            404e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            542e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            822e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-    "Manta G-2460": _reverse_lookup(
-        {
-            979e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            1304e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            1961e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/various/appnote/GigE/GigE-Cameras_AppNote_PIV-Min-Time-Between-Exposures.pdf retrieved 2024-04-05  # noqa: E501
-    "Manta G-609": lambda _, __: 47e-6,
-    # cite: https://cdn.alliedvision.com/fileadmin/content/documents/products/cameras/Mako/techman/Mako_TechMan_en.pdf retrieved 2024-04-05  # noqa: E501
-    "Mako G-040": _reverse_lookup(
-        {
-            101e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            140e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            217e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-    "Mako G-125": lambda _, __: 70e-6,
-    # Assume 12 bits: 10 bits = 275e-6
-    "Mako G-234": _reverse_lookup(
-        {
-            356e-6: (
-                "Mono8",
-                "BayerRG8",
-                "BayerRG12",
-                "BayerRG12Packed",
-                "YUV411Packed",
-                "YUV422Packed",
-            ),
-            # Assume 12 bits: 10 bits = 563e-6
-            726e-6: ("RGB8Packed", "BRG8Packed", "YUV444Packed"),
-        }
-    ),
-    "Mako G-507": _reverse_lookup(
-        {
-            270e-6: (
-                "Mono8",
-                "Mono12Packed",
-                "BayerRG8",
-                "BayerRG12Packed",
-                "YUV411Packed",
-            ),
-            363e-6: ("Mono12", "BayerRG12", "YUV422Packed"),
-            554e-6: ("RGB8Packed", "BGR8Packed", "YUV444Packed"),
-        }
-    ),
-}
-
-
 class AravisDriver(ADBase):
     # If instantiating a new instance, ensure it is supported in the _deadtimes dict
     """Generic Driver supporting the Manta and Mako drivers.
@@ -142,15 +35,4 @@ class AravisDriver(ADBase):
             AravisTriggerMode, prefix + "TriggerMode"
         )
         self.trigger_source = epics_signal_rw_rbv(str, prefix + "TriggerSource")
-        self.model = epics_signal_r(str, prefix + "Model_RBV")
-        self.pixel_format = epics_signal_rw_rbv(str, prefix + "PixelFormat")
-        self.dead_time: Optional[float] = None
         super().__init__(prefix, name=name)
-
-    async def fetch_deadtime(self) -> None:
-        # All known in-use version B/C have same deadtime as non-B/C
-        model: str = (await self.model.get_value()).removesuffix("B").removesuffix("C")
-        if model not in _deadtimes:
-            raise ValueError(f"Model {model} does not have defined deadtimes")
-        pixel_format: str = await self.pixel_format.get_value()
-        self.dead_time = _deadtimes.get(model)(pixel_format, model)

ophyd_async/epics/demo/__init__.py

@@ -6,23 +6,23 @@ import random
 import string
 import subprocess
 import sys
-import time
+from dataclasses import replace
 from enum import Enum
 from pathlib import Path
-from typing import Callable, List, Optional
 
 import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
-    AsyncStatus,
     ConfigSignal,
     Device,
     DeviceVector,
     HintedSignal,
     StandardReadable,
+    WatchableAsyncStatus,
     observe_value,
 )
+from ophyd_async.core.utils import WatcherUpdate
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -85,46 +85,41 @@ class Mover(StandardReadable, Movable, Stoppable):
         # Readback should be named the same as its parent in read()
         self.readback.set_name(name)
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
+    async def _move(self, new_position: float):
         self._set_success = True
         # time.monotonic won't go backwards in case of NTP corrections
-        start = time.monotonic()
         old_position, units, precision = await asyncio.gather(
             self.setpoint.get_value(),
             self.units.get_value(),
             self.precision.get_value(),
         )
         # 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):
-            for watcher in watchers:
-                watcher(
-                    name=self.name,
-                    current=current_position,
-                    initial=old_position,
-                    target=new_position,
-                    unit=units,
-                    precision=precision,
-                    time_elapsed=time.monotonic() - start,
-                )
-            if np.isclose(current_position, new_position):
-                break
+        move_status = self.setpoint.set(new_position, wait=True)
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
+        # return a template to set() which it can use to yield progress updates
+        return (
+            WatcherUpdate(
+                initial=old_position,
+                current=old_position,
+                target=new_position,
+                unit=units,
+                precision=precision,
+            ),
+            move_status,
+        )
 
-    def move(self, new_position: float, timeout: Optional[float] = None):
-        """Commandline only synchronous move of a Motor"""
-        from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
-
-        if in_bluesky_event_loop():
-            raise RuntimeError("Will deadlock run engine if run in a plan")
-        call_in_bluesky_event_loop(self._move(new_position), timeout)  # type: ignore
-
-    # TODO: this fails if we call from the cli, but works if we "ipython await" it
-    def set(self, new_position: float, timeout: Optional[float] = None) -> AsyncStatus:
-        watchers: List[Callable] = []
-        coro = asyncio.wait_for(self._move(new_position, watchers), timeout=timeout)
-        return AsyncStatus(coro, watchers)
+    @WatchableAsyncStatus.wrap  # uses the timeout argument from the function it wraps
+    async def set(self, new_position: float, timeout: float | None = None):
+        update, _ = await self._move(new_position)
+        async for current_position in observe_value(self.readback):
+            yield replace(
+                update,
+                name=self.name,
+                current=current_position,
+            )
+            if np.isclose(current_position, new_position):
+                break
 
     async def stop(self, success=True):
         self._set_success = success

ophyd_async/epics/motion/motor.py

@@ -1,10 +1,17 @@
 import asyncio
-import time
-from typing import Callable, List, Optional
+from dataclasses import replace
 
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, ConfigSignal, HintedSignal, StandardReadable
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+)
+from ophyd_async.core.signal import observe_value
+from ophyd_async.core.utils import WatcherUpdate
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -41,54 +48,46 @@ class Motor(StandardReadable, Movable, Stoppable):
         self.user_readback.set_name(name)
 
     async def _move(
-        self, new_position: float, watchers: Optional[List[Callable]] = None
-    ):
-        if watchers is None:
-            watchers = []
+        self, new_position: float
+    ) -> tuple[WatcherUpdate[float], AsyncStatus]:
         self._set_success = True
-        start = time.monotonic()
         old_position, units, precision = await asyncio.gather(
             self.user_setpoint.get_value(),
             self.motor_egu.get_value(),
             self.precision.get_value(),
         )
-
-        def update_watchers(current_position: float):
-            for watcher in watchers:
-                watcher(
-                    name=self.name,
-                    current=current_position,
-                    initial=old_position,
-                    target=new_position,
-                    unit=units,
-                    precision=precision,
-                    time_elapsed=time.monotonic() - start,
-                )
-
-        self.user_readback.subscribe_value(update_watchers)
-        try:
-            await self.user_setpoint.set(new_position)
-        finally:
-            self.user_readback.clear_sub(update_watchers)
+        move_status = self.user_setpoint.set(new_position, wait=True)
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
+        return (
+            WatcherUpdate(
+                initial=old_position,
+                current=old_position,
+                target=new_position,
+                unit=units,
+                precision=precision,
+            ),
+            move_status,
+        )
 
-    def move(self, new_position: float, timeout: Optional[float] = None):
-        """Commandline only synchronous move of a Motor"""
-        from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
-
-        if in_bluesky_event_loop():
-            raise RuntimeError("Will deadlock run engine if run in a plan")
-        call_in_bluesky_event_loop(self._move(new_position), timeout)  # type: ignore
-
-    def set(self, new_position: float, timeout: Optional[float] = None) -> AsyncStatus:
-        watchers: List[Callable] = []
-        coro = asyncio.wait_for(self._move(new_position, watchers), timeout=timeout)
-        return AsyncStatus(coro, watchers)
+    @WatchableAsyncStatus.wrap
+    async def set(self, new_position: float, timeout: float | None = None):
+        update, move_status = await self._move(new_position)
+        async for current_position in observe_value(
+            self.user_readback, done_status=move_status
+        ):
+            if not self._set_success:
+                raise RuntimeError("Motor was stopped")
+            yield replace(
+                update,
+                name=self.name,
+                current=current_position,
+            )
 
     async def stop(self, success=False):
         self._set_success = success
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
-        status = self.motor_stop.trigger(wait=False)
-        await status
+        await self.motor_stop.trigger(wait=False)
+        # Trigger any callbacks
+        await self.user_readback._backend.put(await self.user_readback.get_value())

ophyd_async/epics/pvi/pvi.py

@@ -91,7 +91,7 @@ def _verify_common_blocks(entry: PVIEntry, common_device: Type[Device]):
         return
     common_sub_devices = get_type_hints(common_device)
     for sub_name, sub_device in common_sub_devices.items():
-        if sub_name in ("_name", "parent"):
+        if sub_name.startswith("_") or sub_name == "parent":
             continue
         assert entry.sub_entries
         device_t, is_optional = _strip_union(sub_device)
@@ -161,7 +161,7 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
     sub_devices = (
         (field, field_type)
         for field, field_type in get_type_hints(device_t).items()
-        if field not in ("_name", "parent")
+        if not field.startswith("_") and field != "parent"
     )
 
     for device_name, device_cls in sub_devices:

ophyd_async/epics/signal/__init__.py

@@ -1,8 +1,15 @@
-from .signal import epics_signal_r, epics_signal_rw, epics_signal_w, epics_signal_x
+from .signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+    epics_signal_w,
+    epics_signal_x,
+)
 
 __all__ = [
     "epics_signal_r",
     "epics_signal_rw",
+    "epics_signal_rw_rbv",
     "epics_signal_w",
     "epics_signal_x",
 ]

ophyd_async/planstubs/__init__.py

@@ -1,5 +1,9 @@
+from .ensure_connected import ensure_connected
 from .prepare_trigger_and_dets import (
     prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
 )
 
-__all__ = ["prepare_static_seq_table_flyer_and_detectors_with_same_trigger"]
+__all__ = [
+    "prepare_static_seq_table_flyer_and_detectors_with_same_trigger",
+    "ensure_connected",
+]

ophyd_async/planstubs/ensure_connected.py

@@ -0,0 +1,22 @@
+import bluesky.plan_stubs as bps
+
+from ophyd_async.core.device import Device
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, wait_for_connection
+
+
+def ensure_connected(
+    *devices: Device,
+    mock: bool = False,
+    timeout: float = DEFAULT_TIMEOUT,
+    force_reconnect=False,
+):
+    yield from bps.wait_for(
+        [
+            lambda: wait_for_connection(
+                **{
+                    device.name: device.connect(mock, timeout, force_reconnect)
+                    for device in devices
+                }
+            )
+        ]
+    )

ophyd_async/protocols.py

@@ -1,9 +1,20 @@
+from __future__ import annotations
+
 from abc import abstractmethod
-from typing import Dict, Protocol, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generic,
+    Protocol,
+    TypeVar,
+    runtime_checkable,
+)
 
 from bluesky.protocols import DataKey, HasName, Reading
 
-from ophyd_async.core.async_status import AsyncStatus
+if TYPE_CHECKING:
+    from ophyd_async.core.async_status import AsyncStatus
 
 
 @runtime_checkable
@@ -94,3 +105,22 @@ class AsyncStageable(Protocol):
         unstaging.
         """
         ...
+
+
+C = TypeVar("C", contravariant=True)
+
+
+class Watcher(Protocol, Generic[C]):
+    @staticmethod
+    def __call__(
+        *,
+        current: C,
+        initial: C,
+        target: C,
+        name: str | None,
+        unit: str | None,
+        precision: float | None,
+        fraction: float | None,
+        time_elapsed: float | None,
+        time_remaining: float | None,
+    ) -> Any: ...

ophyd_async/sim/demo/sim_motor.py

@@ -1,13 +1,18 @@
 import asyncio
 import time
-from typing import Callable, List, Optional
+from dataclasses import replace
 
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import StandardReadable
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.signal import soft_signal_r_and_setter, soft_signal_rw
+from ophyd_async.core.async_status import AsyncStatus, WatchableAsyncStatus
+from ophyd_async.core.signal import (
+    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):
@@ -27,10 +32,10 @@ class SimMotor(StandardReadable, Movable, Stoppable):
 
         with self.add_children_as_readables(ConfigSignal):
             self.velocity = soft_signal_rw(float, 1.0)
-            self.egu = soft_signal_rw(float, "mm")
+            self.egu = soft_signal_rw(str, "mm")
 
         self._instant = instant
-        self._move_task: Optional[asyncio.Task] = None
+        self._move_status: AsyncStatus | None = None
 
         # Define some signals
         self.user_setpoint = soft_signal_rw(float, 0)
@@ -44,21 +49,37 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         """
         Stop the motor if it is moving
         """
-        if self._move_task:
-            self._move_task.cancel()
-            self._move_task = None
+        if self._move_status:
+            self._move_status.task.cancel()
+            self._move_status = None
+
+        async def trigger_callbacks():
+            await self.user_readback._backend.put(
+                await self.user_readback._backend.get_value()
+            )
+
+        asyncio.create_task(trigger_callbacks())
 
         self._set_success = success
 
-    def set(self, new_position: float, timeout: Optional[float] = None) -> AsyncStatus:  # noqa: F821
+    @WatchableAsyncStatus.wrap
+    async def set(self, new_position: float, timeout: float | None = None):
         """
         Asynchronously move the motor to a new position.
         """
-        watchers: List[Callable] = []
-        coro = asyncio.wait_for(self._move(new_position, watchers), timeout=timeout)
-        return AsyncStatus(coro, watchers)
+        update, move_status = await self._move(new_position, timeout)
+        async for current_position in observe_value(
+            self.user_readback, done_status=move_status
+        ):
+            if not self._set_success:
+                raise RuntimeError("Motor was stopped")
+            yield replace(
+                update,
+                name=self.name,
+                current=current_position,
+            )
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
+    async def _move(self, new_position: float, timeout: float | None = None):
         """
         Start the motor moving to a new position.
 
@@ -67,6 +88,7 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         """
         self.stop()
         start = time.monotonic()
+        self._set_success = True
 
         current_position = await self.user_readback.get_value()
         distance = abs(new_position - current_position)
@@ -94,25 +116,18 @@ class SimMotor(StandardReadable, Movable, Stoppable):
 
                 self._user_readback_set(current_position)
 
-                # notify watchers of the new position
-                for watcher in watchers:
-                    watcher(
-                        name=self.name,
-                        current=current_position,
-                        initial=old_position,
-                        target=new_position,
-                        unit=units,
-                        time_elapsed=time.monotonic() - start,
-                    )
-
                 # 10hz update loop
                 await asyncio.sleep(0.1)
 
-        # set up a task that updates the motor position at 10hz
-        self._move_task = asyncio.create_task(update_position())
-
-        try:
-            await self._move_task
-        finally:
-            if not self._set_success:
-                raise RuntimeError("Motor was stopped")
+        # set up a task that updates the motor position at ~10hz
+        self._move_status = AsyncStatus(asyncio.wait_for(update_position(), timeout))
+
+        return (
+            WatcherUpdate(
+                initial=old_position,
+                current=old_position,
+                target=new_position,
+                unit=units,
+            ),
+            self._move_status,
+        )

{ophyd_async-0.3a4.dist-info → ophyd_async-0.3a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a4
+Version: 0.3a5
 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