ophyd-async 0.8.0a6__py3-none-any.whl → 0.9.0a1__py3-none-any.whl

ophyd_async/fastcs/core.py

@@ -2,8 +2,8 @@ from ophyd_async.core import Device, DeviceConnector
 from ophyd_async.epics.core import PviDeviceConnector
 
 
-def fastcs_connector(device: Device, uri: str) -> DeviceConnector:
+def fastcs_connector(device: Device, uri: str, error_hint: str = "") -> DeviceConnector:
     # TODO: add Tango support based on uri scheme
-    connector = PviDeviceConnector(uri)
+    connector = PviDeviceConnector(uri, error_hint)
     connector.create_children_from_annotations(device)
     return connector

ophyd_async/fastcs/panda/_block.py

@@ -36,14 +36,14 @@ class PulseBlock(Device):
 
 
 class PcompDirection(StrictEnum):
-    positive = "Positive"
-    negative = "Negative"
-    either = "Either"
+    POSITIVE = "Positive"
+    NEGATIVE = "Negative"
+    EITHER = "Either"
 
 
 class BitMux(SubsetEnum):
-    zero = "ZERO"
-    one = "ONE"
+    ZERO = "ZERO"
+    ONE = "ONE"
 
 
 class PcompBlock(Device):
@@ -57,10 +57,10 @@ class PcompBlock(Device):
 
 
 class TimeUnits(StrictEnum):
-    min = "min"
-    s = "s"
-    ms = "ms"
-    us = "us"
+    MIN = "min"
+    S = "s"
+    MS = "ms"
+    US = "us"
 
 
 class SeqBlock(Device):

ophyd_async/fastcs/panda/_control.py

@@ -19,8 +19,8 @@ class PandaPcapController(DetectorController):
 
     async def prepare(self, trigger_info: TriggerInfo):
         assert trigger_info.trigger in (
-            DetectorTrigger.constant_gate,
-            DetectorTrigger.variable_gate,
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.VARIABLE_GATE,
         ), "Only constant_gate and variable_gate triggering is supported on the PandA"
 
     async def arm(self):

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -9,6 +9,8 @@ from ._block import CommonPandaBlocks
 from ._control import PandaPcapController
 from ._writer import PandaHDFWriter
 
+MINIMUM_PANDA_IOC = "0.11.4"
+
 
 class HDFPanda(CommonPandaBlocks, StandardDetector):
     def __init__(
@@ -18,8 +20,9 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         config_sigs: Sequence[SignalR] = (),
         name: str = "",
     ):
+        error_hint = f"Is PandABlocks-ioc at least version {MINIMUM_PANDA_IOC}?"
         # This has to be first so we make self.pcap
-        connector = fastcs_connector(self, prefix)
+        connector = fastcs_connector(self, prefix, error_hint)
         controller = PandaPcapController(pcap=self.pcap)
         writer = PandaHDFWriter(
             path_provider=path_provider,

ophyd_async/fastcs/panda/_trigger.py

@@ -20,8 +20,8 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
 
     async def prepare(self, value: SeqTableInfo):
         await asyncio.gather(
-            self.seq.prescale_units.set(TimeUnits.us),
-            self.seq.enable.set(BitMux.zero),
+            self.seq.prescale_units.set(TimeUnits.US),
+            self.seq.enable.set(BitMux.ZERO),
         )
         await asyncio.gather(
             self.seq.prescale.set(value.prescale_as_us),
@@ -30,14 +30,14 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.seq.enable.set(BitMux.one)
+        await self.seq.enable.set(BitMux.ONE)
         await wait_for_value(self.seq.active, True, timeout=1)
 
     async def complete(self) -> None:
         await wait_for_value(self.seq.active, False, timeout=None)
 
     async def stop(self):
-        await self.seq.enable.set(BitMux.zero)
+        await self.seq.enable.set(BitMux.ZERO)
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
@@ -68,7 +68,7 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         self.pcomp = pcomp
 
     async def prepare(self, value: PcompInfo):
-        await self.pcomp.enable.set(BitMux.zero)
+        await self.pcomp.enable.set(BitMux.ZERO)
         await asyncio.gather(
             self.pcomp.start.set(value.start_postion),
             self.pcomp.width.set(value.pulse_width),
@@ -78,12 +78,12 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.pcomp.enable.set(BitMux.one)
+        await self.pcomp.enable.set(BitMux.ONE)
         await wait_for_value(self.pcomp.active, True, timeout=1)
 
     async def complete(self, timeout: float | None = None) -> None:
         await wait_for_value(self.pcomp.active, False, timeout=timeout)
 
     async def stop(self):
-        await self.pcomp.enable.set(BitMux.zero)
+        await self.pcomp.enable.set(BitMux.ZERO)
         await wait_for_value(self.pcomp.active, False, timeout=1)

ophyd_async/plan_stubs/_fly.py

@@ -62,7 +62,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
 
     trigger_info = TriggerInfo(
         number_of_triggers=number_of_frames * repeats,
-        trigger=DetectorTrigger.constant_gate,
+        trigger=DetectorTrigger.CONSTANT_GATE,
         deadtime=deadtime,
         livetime=exposure,
         frame_timeout=frame_timeout,

ophyd_async/sim/demo/_sim_motor.py

@@ -2,6 +2,7 @@ import asyncio
 import contextlib
 import time
 
+import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
@@ -44,22 +45,20 @@ class SimMotor(StandardReadable, Movable, Stoppable):
 
     async def _move(self, old_position: float, new_position: float, move_time: float):
         start = time.monotonic()
-        distance = abs(new_position - old_position)
-        while True:
-            time_elapsed = round(time.monotonic() - start, 2)
-
-            # update position based on time elapsed
-            if time_elapsed >= move_time:
-                # successfully reached our target position
-                self._user_readback_set(new_position)
-                break
-            else:
-                current_position = old_position + distance * time_elapsed / move_time
-
-            self._user_readback_set(current_position)
-
-            # 10hz update loop
-            await asyncio.sleep(0.1)
+        # Make an array of relative update times at 10Hz intervals
+        update_times = np.arange(0.1, move_time, 0.1)
+        # With the end position appended
+        update_times = np.concatenate((update_times, [move_time]))
+        # Interpolate the [old, new] position array with those update times
+        new_positions = np.interp(
+            update_times, [0, move_time], [old_position, new_position]
+        )
+        for update_time, new_position in zip(update_times, new_positions, strict=True):
+            # Calculate how long to wait to get there
+            relative_time = time.monotonic() - start
+            await asyncio.sleep(update_time - relative_time)
+            # Update the readback position
+            self._user_readback_set(new_position)
 
     @WatchableAsyncStatus.wrap
     async def set(self, value: float):
@@ -75,22 +74,25 @@ class SimMotor(StandardReadable, Movable, Stoppable):
             self.velocity.get_value(),
         )
         # If zero velocity, do instant move
-        move_time = abs(new_position - old_position) / velocity if velocity else 0
-        self._move_status = AsyncStatus(
-            self._move(old_position, new_position, move_time)
-        )
-        # If stop is called then this will raise a CancelledError, ignore it
-        with contextlib.suppress(asyncio.CancelledError):
-            async for current_position in observe_value(
-                self.user_readback, done_status=self._move_status
-            ):
-                yield WatcherUpdate(
-                    current=current_position,
-                    initial=old_position,
-                    target=new_position,
-                    name=self.name,
-                    unit=units,
-                )
+        if velocity == 0:
+            self._user_readback_set(new_position)
+        else:
+            move_time = abs(new_position - old_position) / velocity
+            self._move_status = AsyncStatus(
+                self._move(old_position, new_position, move_time)
+            )
+            # If stop is called then this will raise a CancelledError, ignore it
+            with contextlib.suppress(asyncio.CancelledError):
+                async for current_position in observe_value(
+                    self.user_readback, done_status=self._move_status
+                ):
+                    yield WatcherUpdate(
+                        current=current_position,
+                        initial=old_position,
+                        target=new_position,
+                        name=self.name,
+                        unit=units,
+                    )
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
 

ophyd_async/tango/core/_tango_transport.py

@@ -189,7 +189,7 @@ class AttributeProxy(TangoProxy):
                 raise TimeoutError(f"{self._name} attr put failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(
-                    f"{self._name} device" f" failure: {de.args[0].desc}"
+                    f"{self._name} device failure: {de.args[0].desc}"
                 ) from de
 
         else:

ophyd_async/testing/__init__.py

@@ -0,0 +1,33 @@
+from ._assert import (
+    assert_configuration,
+    assert_emitted,
+    assert_reading,
+    assert_value,
+)
+from ._mock_signal_utils import (
+    callback_on_mock_put,
+    get_mock,
+    get_mock_put,
+    mock_puts_blocked,
+    reset_mock_put_calls,
+    set_mock_put_proceeds,
+    set_mock_value,
+    set_mock_values,
+)
+from ._wait_for_pending import wait_for_pending_wakeups
+
+__all__ = [
+    "assert_configuration",
+    "assert_emitted",
+    "assert_reading",
+    "assert_value",
+    "callback_on_mock_put",
+    "get_mock",
+    "get_mock_put",
+    "mock_puts_blocked",
+    "reset_mock_put_calls",
+    "set_mock_put_proceeds",
+    "set_mock_value",
+    "set_mock_values",
+    "wait_for_pending_wakeups",
+]

ophyd_async/testing/_assert.py

@@ -0,0 +1,128 @@
+from collections.abc import Mapping
+from typing import Any
+
+from bluesky.protocols import Reading
+
+from ophyd_async.core import AsyncConfigurable, AsyncReadable, SignalDatatypeT, SignalR
+
+
+def _generate_assert_error_msg(name: str, expected_result, actual_result) -> str:
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+    return (
+        f"Expected {WARNING}{name}{ENDC} to produce"
+        + f"\n{FAIL}{expected_result}{ENDC}"
+        + f"\nbut actually got \n{FAIL}{actual_result}{ENDC}"
+    )
+
+
+async def assert_value(signal: SignalR[SignalDatatypeT], value: Any) -> None:
+    """Assert a signal's value and compare it an expected signal.
+
+    Parameters
+    ----------
+    signal:
+        signal with get_value.
+    value:
+        The expected value from the signal.
+
+    Notes
+    -----
+    Example usage::
+        await assert_value(signal, value)
+
+    """
+    actual_value = await signal.get_value()
+    assert actual_value == value, _generate_assert_error_msg(
+        name=signal.name,
+        expected_result=value,
+        actual_result=actual_value,
+    )
+
+
+async def assert_reading(
+    readable: AsyncReadable, expected_reading: Mapping[str, Reading]
+) -> None:
+    """Assert readings from readable.
+
+    Parameters
+    ----------
+    readable:
+        Callable with readable.read function that generate readings.
+
+    reading:
+        The expected readings from the readable.
+
+    Notes
+    -----
+    Example usage::
+        await assert_reading(readable, reading)
+
+    """
+    actual_reading = await readable.read()
+    assert expected_reading == actual_reading, _generate_assert_error_msg(
+        name=readable.name,
+        expected_result=expected_reading,
+        actual_result=actual_reading,
+    )
+
+
+async def assert_configuration(
+    configurable: AsyncConfigurable,
+    configuration: Mapping[str, Reading],
+) -> None:
+    """Assert readings from Configurable.
+
+    Parameters
+    ----------
+    configurable:
+        Configurable with Configurable.read function that generate readings.
+
+    configuration:
+        The expected readings from configurable.
+
+    Notes
+    -----
+    Example usage::
+        await assert_configuration(configurable configuration)
+
+    """
+    actual_configurable = await configurable.read_configuration()
+    assert configuration == actual_configurable, _generate_assert_error_msg(
+        name=configurable.name,
+        expected_result=configuration,
+        actual_result=actual_configurable,
+    )
+
+
+def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
+    """Assert emitted document generated by running a Bluesky plan
+
+    Parameters
+    ----------
+    Doc:
+        A dictionary
+
+    numbers:
+        expected emission in kwarg from
+
+    Notes
+    -----
+    Example usage::
+        docs = defaultdict(list)
+        RE.subscribe(lambda name, doc: docs[name].append(doc))
+        RE(my_plan())
+        assert_emitted(docs, start=1, descriptor=1, event=1, stop=1)
+    """
+    assert list(docs) == list(numbers), _generate_assert_error_msg(
+        name="documents",
+        expected_result=list(numbers),
+        actual_result=list(docs),
+    )
+    actual_numbers = {name: len(d) for name, d in docs.items()}
+    assert actual_numbers == numbers, _generate_assert_error_msg(
+        name="emitted",
+        expected_result=numbers,
+        actual_result=actual_numbers,
+    )

ophyd_async/{core → testing}/_mock_signal_utils.py

@@ -1,12 +1,16 @@
 from collections.abc import Awaitable, Callable, Iterable
-from contextlib import asynccontextmanager, contextmanager
+from contextlib import contextmanager
 from unittest.mock import AsyncMock, Mock
 
-from ._device import Device
-from ._mock_signal_backend import MockSignalBackend
-from ._signal import Signal, SignalConnector, SignalR
-from ._soft_signal_backend import SignalDatatypeT
-from ._utils import LazyMock
+from ophyd_async.core import (
+    Device,
+    LazyMock,
+    MockSignalBackend,
+    Signal,
+    SignalConnector,
+    SignalDatatypeT,
+    SignalR,
+)
 
 
 def get_mock(device: Device | Signal) -> Mock:
@@ -40,8 +44,8 @@ def set_mock_put_proceeds(signal: Signal, proceeds: bool):
         backend.put_proceeds.clear()
 
 
-@asynccontextmanager
-async def mock_puts_blocked(*signals: Signal):
+@contextmanager
+def mock_puts_blocked(*signals: Signal):
     for signal in signals:
         set_mock_put_proceeds(signal, False)
     yield

ophyd_async/testing/_wait_for_pending.py

@@ -0,0 +1,22 @@
+import asyncio
+
+
+async def wait_for_pending_wakeups(max_yields=20, raise_if_exceeded=True):
+    """Allow any ready asyncio tasks to be woken up.
+
+    Used in:
+
+    - Tests to allow tasks like ``set()`` to start so that signal
+      puts can be tested
+    - `observe_value` to allow it to be wrapped in `asyncio.wait_for`
+      with a timeout
+    """
+    loop = asyncio.get_event_loop()
+    # If anything has called loop.call_soon or is scheduled a wakeup
+    # then let it run
+    for _ in range(max_yields):
+        await asyncio.sleep(0)
+        if not loop._ready:  # type: ignore # noqa: SLF001
+            return
+    if raise_if_exceeded:
+        raise RuntimeError(f"Tasks still scheduling wakeups after {max_yields} yields")

{ophyd_async-0.8.0a6.dist-info → ophyd_async-0.9.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.8.0a6
+Version: 0.9.0a1
 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
@@ -37,6 +37,7 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -67,6 +68,7 @@ Requires-Dist: ophyd_async[tango]; extra == "dev"
 Requires-Dist: inflection; extra == "dev"
 Requires-Dist: ipython; extra == "dev"
 Requires-Dist: ipywidgets; extra == "dev"
+Requires-Dist: import-linter; extra == "dev"
 Requires-Dist: matplotlib; extra == "dev"
 Requires-Dist: myst-parser; extra == "dev"
 Requires-Dist: numpydoc; extra == "dev"