ophyd-async 0.10.0a4__tar.gz → 0.10.1__tar.gz

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a4
+Version: 0.10.1
 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
@@ -43,7 +43,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: bluesky>=1.13.1rc2
-Requires-Dist: event-model>=1.22.1
+Requires-Dist: event-model>=1.23
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/pyproject.toml

@@ -15,7 +15,7 @@ description = "Asynchronous Bluesky hardware abstraction code, compatible with c
 dependencies = [
     "numpy",
     "bluesky>=1.13.1rc2",
-    "event-model>=1.22.1",
+    "event-model>=1.23",
     "pyyaml",
     "colorlog",
     "pydantic>=2.0",

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.10.0a4'
-__version_tuple__ = version_tuple = (0, 10, 0, 'a4')
+__version__ = version = '0.10.1'
+__version_tuple__ = version_tuple = (0, 10, 1)

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/core/_derived_signal.py

@@ -248,7 +248,7 @@ def derived_signal_rw(
     if raw_to_derived_datatype != set_derived_datatype:
         msg = (
             f"{raw_to_derived} has datatype {raw_to_derived_datatype} "
-            f"!= {set_derived_datatype} dataype {set_derived_datatype}"
+            f"!= {set_derived_datatype} datatype {set_derived_datatype}"
         )
         raise TypeError(msg)
 

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/core/_derived_signal_backend.py

@@ -61,7 +61,7 @@ class Transform(BaseModel, Generic[RawT, DerivedT]):
 TransformT = TypeVar("TransformT", bound=Transform)
 
 
-def filter_by_type(raw_devices: Mapping[str, Any], type_: type[T]) -> dict[str, T]:
+def validate_by_type(raw_devices: Mapping[str, Any], type_: type[T]) -> dict[str, T]:
     filtered_devices: dict[str, T] = {}
     for name, device in raw_devices.items():
         if not isinstance(device, type_):
@@ -91,21 +91,23 @@ class SignalTransformer(Generic[TransformT]):
 
     @cached_property
     def raw_locatables(self) -> dict[str, AsyncLocatable]:
-        return filter_by_type(self._raw_devices, AsyncLocatable)
+        return validate_by_type(self._raw_devices, AsyncLocatable)
 
     @cached_property
     def transform_readables(self) -> dict[str, AsyncReadable]:
-        return filter_by_type(self._transform_devices, AsyncReadable)
+        return validate_by_type(self._transform_devices, AsyncReadable)
 
     @cached_property
     def raw_and_transform_readables(self) -> dict[str, AsyncReadable]:
-        return filter_by_type(
+        return validate_by_type(
             self._raw_devices | self._transform_devices, AsyncReadable
         )
 
     @cached_property
     def raw_and_transform_subscribables(self) -> dict[str, Subscribable]:
-        return filter_by_type(self._raw_devices | self._transform_devices, Subscribable)
+        return validate_by_type(
+            self._raw_devices | self._transform_devices, Subscribable
+        )
 
     def _complete_cached_reading(self) -> dict[str, Reading] | None:
         if self._cached_readings and len(self._cached_readings) == len(

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/core/_hdf_dataset.py

@@ -23,7 +23,7 @@ class HDFDatasetDescription(BaseModel):
     """The dataset name within the HDF file,
     e.g. /entry/data/data or /entry/instrument/NDAttributes/sum"""
 
-    shape: tuple[int, ...] = Field(default_factory=tuple)
+    shape: tuple[int | None, ...] = Field(default_factory=tuple)
     """The shape of a single event's data in the HDF file,
     e.g. (1, 768, 1024) for arrays or () for scalars"""
 

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/core/_providers.py

@@ -228,5 +228,5 @@ class DatasetDescriber(Protocol):
         """Return the numpy datatype for this dataset."""
 
     @abstractmethod
-    async def shape(self) -> tuple[int, ...]:
+    async def shape(self) -> tuple[int | None, ...]:
         """Get the shape of the data collection."""

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/core/_signal.py

@@ -163,7 +163,12 @@ class _SignalCache(Generic[SignalDatatypeT]):
             self._notify(function, want_value)
 
     def unsubscribe(self, function: Callback) -> bool:
-        self._listeners.pop(function)
+        _listener = self._listeners.pop(function, None)
+        if not _listener:
+            self._signal.log.warning(
+                f"Unsubscribe failed: subscriber {function} was not found "
+                f" in listeners list: {list(self._listeners)}"
+            )
         return self._staged or bool(self._listeners)
 
     def set_staged(self, staged: bool) -> bool:

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/core/_signal_backend.py

@@ -176,7 +176,7 @@ def _datakey_dtype_numpy(
         raise TypeError(f"Can't make dtype_numpy for {datatype}")
 
 
-def _datakey_shape(value: SignalDatatype) -> list[int]:
+def _datakey_shape(value: SignalDatatype) -> list[int | None]:
     if type(value) in _primitive_dtype or isinstance(value, EnumTypes):
         return []
     elif isinstance(value, np.ndarray):

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/epics/adcore/_core_logic.py

@@ -7,6 +7,7 @@ from ophyd_async.core import (
     DetectorController,
     DetectorTrigger,
     TriggerInfo,
+    observe_value,
     set_and_wait_for_value,
 )
 
@@ -89,34 +90,57 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                 self.driver.acquire_period.set(full_frame_time, timeout=timeout),
             )
 
-    async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
+    async def start_acquiring_driver_and_ensure_status(
+        self,
+        start_timeout: float = DEFAULT_TIMEOUT,
+        state_timeout: float = DEFAULT_TIMEOUT,
+    ) -> AsyncStatus:
         """Start acquiring driver, raising ValueError if the detector is in a bad state.
 
         This sets driver.acquire to True, and waits for it to be True up to a timeout.
         Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES,
         and otherwise raises a ValueError.
 
+
+        :param start_timeout:
+            Timeout used for waiting for the driver to start
+            acquiring.
+        :param state_timeout:
+            Timeout used for waiting for the detector to be in a good
+            state after it stops acquiring.
         :returns AsyncStatus:
             An AsyncStatus that can be awaited to set driver.acquire to True and perform
             subsequent raising (if applicable) due to detector state.
+
         """
         status = await set_and_wait_for_value(
             self.driver.acquire,
             True,
-            timeout=DEFAULT_TIMEOUT,
+            timeout=start_timeout,
             wait_for_set_completion=False,
         )
 
         async def complete_acquisition() -> None:
-            # NOTE: possible race condition here between the callback from
-            # set_and_wait_for_value and the detector state updating.
             await status
-            state = await self.driver.detector_state.get_value()
-            if state not in self.good_states:
-                raise ValueError(
-                    f"Final detector state {state.value} not "
-                    "in valid end states: {self.good_states}"
-                )
+            state = None
+            try:
+                async for state in observe_value(
+                    self.driver.detector_state, done_timeout=state_timeout
+                ):
+                    if state in self.good_states:
+                        return
+            except asyncio.TimeoutError as exc:
+                if state is not None:
+                    raise ValueError(
+                        f"Final detector state {state.value} not in valid end "
+                        f"states: {self.good_states}"
+                    ) from exc
+                else:
+                    # No updates from the detector, something else is wrong
+                    raise asyncio.TimeoutError(
+                        "Could not monitor detector state: "
+                        + self.driver.detector_state.source
+                    ) from exc
 
         return AsyncStatus(complete_acquisition())
 

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async/epics/adcore/_hdf_writer.py

@@ -1,6 +1,7 @@
 import asyncio
 from collections.abc import AsyncIterator
 from pathlib import Path
+from typing import TypeGuard
 from xml.etree import ElementTree as ET
 
 from bluesky.protocols import StreamAsset
@@ -22,6 +23,10 @@ from ._utils import (
 )
 
 
+def _is_fully_described(shape: tuple[int | None, ...]) -> TypeGuard[tuple[int, ...]]:
+    return None not in shape
+
+
 class ADHDFWriter(ADWriter[NDFileHDFIO]):
     """Allow `NDFileHDFIO` to be used within `StandardDetector`."""
 
@@ -75,6 +80,16 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         # Determine number of frames that will be saved per HDF chunk
         frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
 
+        if not _is_fully_described(detector_shape):
+            # Questions:
+            # - Can AreaDetector support this?
+            # - How to deal with chunking?
+            # Don't support for now - leave option open to support it later
+            raise ValueError(
+                "Datasets with partially unknown dimensionality "
+                "are not currently supported by ADHDFWriter."
+            )
+
         # Add the main data
         self._datasets = [
             HDFDatasetDescription(

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a4
+Version: 0.10.1
 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
@@ -43,7 +43,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: bluesky>=1.13.1rc2
-Requires-Dist: event-model>=1.22.1
+Requires-Dist: event-model>=1.23
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/src/ophyd_async.egg-info/requires.txt

@@ -1,6 +1,6 @@
 numpy
 bluesky>=1.13.1rc2
-event-model>=1.22.1
+event-model>=1.23
 pyyaml
 colorlog
 pydantic>=2.0

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/tests/core/test_multi_derived_signal.py

@@ -8,6 +8,9 @@ from bluesky.protocols import Reading
 
 from ophyd_async.core import (
     DerivedSignalFactory,
+    SignalRW,
+    Table,
+    derived_signal_rw,
     soft_signal_rw,
 )
 from ophyd_async.sim import (
@@ -22,6 +25,7 @@ from ophyd_async.testing import (
     assert_reading,
     assert_value,
     get_mock,
+    set_mock_value,
 )
 
 
@@ -131,3 +135,55 @@ def test_mismatching_args():
             jack22=soft_signal_rw(float),
             distance=soft_signal_rw(float),
         )
+
+
+@pytest.fixture
+def derived_signal() -> SignalRW[float]:
+    signal_r = soft_signal_rw(int, initial_value=4)
+
+    def _get(ts: int) -> float:
+        return ts
+
+    async def _put(value: float) -> None:
+        pass
+
+    return derived_signal_rw(_get, _put, ts=signal_r)
+
+
+async def test_derived_signal_backend_connect_pass(
+    derived_signal: SignalRW,
+):
+    result = await derived_signal.connect()
+    assert result is None
+
+
+async def test_derived_signal_backend_set_value(
+    derived_signal: SignalRW,
+) -> None:
+    await derived_signal.connect(mock=True)
+    with pytest.raises(RuntimeError):
+        set_mock_value(derived_signal, 1.0)
+
+
+async def test_derived_signal_backend_put_wait_fails(
+    derived_signal: SignalRW,
+) -> None:
+    with pytest.raises(RuntimeError):
+        await derived_signal.set(value=None, wait=False)
+    with pytest.raises(RuntimeError):
+        await derived_signal.set(value=None, wait=True)
+
+
+def test_make_rw_signal_type_mismatch():
+    factory = DerivedSignalFactory(
+        TwoJackTransform,
+        set_derived=None,
+        distance=soft_signal_rw(float),
+        jack1=soft_signal_rw(float),
+        jack2=soft_signal_rw(float),
+    )
+    with pytest.raises(
+        ValueError,
+        match=re.escape("Must define a set_derived method to support derived"),
+    ):
+        factory.derived_signal_rw(datatype=Table, name="")

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/tests/core/test_signal.py

@@ -1013,3 +1013,9 @@ async def test_notify_runtime_error(signal_cache: _SignalCache[Any]) -> None:
 def test_signal_backend_throws_type_error() -> None:
     with pytest.raises(TypeError, match="Unsupported protocol: XYZ"):
         get_signal_backend_type("XYZ")  # type: ignore
+
+
+def test_remove_non_existing_listener():
+    signal_rw = soft_signal_rw(int, initial_value=4)
+    cbs = []
+    assert signal_rw.clear_sub(cbs.append) is None

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/tests/core/test_single_derived_signal.py

@@ -1,12 +1,18 @@
 import asyncio
 import re
-from unittest.mock import call
+from unittest.mock import MagicMock, call, patch
 
 import pytest
+from bluesky.protocols import Reading, Subscribable
 
 from ophyd_async.core import (
+    Callback,
+    Signal,
+    SignalBackend,
+    SignalDatatype,
     derived_signal_r,
     derived_signal_rw,
+    derived_signal_w,
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
@@ -22,6 +28,16 @@ from ophyd_async.testing import (
 )
 
 
+@pytest.fixture
+def movable_beamstop() -> MovableBeamstop:
+    return MovableBeamstop("device")
+
+
+@pytest.fixture
+def readonly_beamstop() -> ReadOnlyBeamstop:
+    return ReadOnlyBeamstop("device")
+
+
 def _get_position(foo: float, bar: float) -> BeamstopPosition:
     if abs(foo) < 1 and abs(bar) < 2:
         return BeamstopPosition.IN_POSITION
@@ -137,14 +153,100 @@ def test_mismatching_args_and_types(func, expected_msg, args):
         derived_signal_r(func, **args)
 
 
+def _get(ts: int) -> float:
+    return ts
+
+
+async def _put(value: float) -> None:
+    pass
+
+
+@pytest.fixture
+def derived_signal_backend() -> SignalBackend[SignalDatatype]:
+    signal_rw = soft_signal_rw(int, initial_value=4)
+    derived = derived_signal_rw(_get, _put, ts=signal_rw)
+    return derived._connector.backend
+
+
 async def test_derived_signal_rw_works_with_signal_r():
     signal_r, _ = soft_signal_r_and_setter(int, initial_value=4)
+    derived = derived_signal_rw(_get, _put, ts=signal_r)
+    assert await derived.get_value() == 4
+
 
-    def _get(ts: int) -> float:
+async def test_validate_by_type(derived_signal_backend: SignalBackend):
+    def float_get(ts: float) -> float:
         return ts
 
-    async def _put(value: float) -> None:
-        pass
+    with pytest.raises(TypeError, match=re.escape(" is not an instance of")):
+        derived_signal_rw(float_get, _put, ts=Signal(derived_signal_backend))
 
-    derived = derived_signal_rw(_get, _put, ts=signal_r)
-    assert await derived.get_value() == 4
+
+async def test_set_derived_not_initialized():
+    sig = derived_signal_r(_get, ts=soft_signal_rw(int, initial_value=4))
+    with pytest.raises(
+        RuntimeError,
+        match="Cannot put as no set_derived method given",
+    ):
+        await sig._connector.backend.put(1.0, True)
+
+
+async def test_derived_update_cached_reading_not_initialized(
+    derived_signal_backend: SignalBackend,
+):
+    class test_cls(Subscribable):
+        def subscribe(self, function: Callback) -> None:
+            pass
+
+        def clear_sub(self, function: Callback) -> None:
+            function("")
+
+        @property
+        def name(self) -> str:
+            return ""
+
+    with patch.object(
+        derived_signal_backend.transformer,  # type: ignore
+        "raw_and_transform_subscribables",
+        {"raw_device": test_cls()},
+    ):
+        with pytest.raises(
+            RuntimeError,
+            match=re.escape(
+                "Cannot update cached reading as it has not been initialised"
+            ),
+        ):  # noqa: E501
+            derived_signal_backend.set_callback(None)
+
+
+async def test_set_derived_callback_already_set(derived_signal_backend: SignalBackend):
+    mock_callback = MagicMock(Callback[Reading])
+    derived_signal_backend.set_callback(mock_callback)
+    with pytest.raises(RuntimeError, match=re.escape("Callback already set for")):
+        derived_signal_backend.set_callback(mock_callback)
+
+
+@patch("ophyd_async.core._derived_signal.get_type_hints", return_value={})
+def test_get_return_datatype_no_type(movable_beamstop: MovableBeamstop):
+    with pytest.raises(
+        TypeError, match=re.escape("does not have a type hint for it's return value")
+    ):
+        derived_signal_r(movable_beamstop._get_position)
+
+
+@patch("ophyd_async.core._derived_signal.get_type_hints", return_value={})
+def test_get_first_arg_datatype_no_type(movable_beamstop: MovableBeamstop):
+    with pytest.raises(
+        TypeError, match=re.escape("does not have a type hinted argument")
+    ):
+        derived_signal_w(movable_beamstop._set_from_position)
+
+
+def test_derived_signal_rw_type_error(movable_beamstop: MovableBeamstop):
+    with patch.object(
+        movable_beamstop, "_set_from_position", movable_beamstop._get_position
+    ):  # noqa: E501
+        with pytest.raises(TypeError):
+            derived_signal_rw(
+                movable_beamstop._get_position, movable_beamstop._set_from_position
+            )  # noqa: E501

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/tests/epics/adcore/test_drivers.py

@@ -68,7 +68,6 @@ async def test_start_acquiring_driver_and_ensure_status_flags_immediate_failure(
         await acquiring
 
 
-@patch("ophyd_async.core._detector.DEFAULT_TIMEOUT", 0.2)
 async def test_start_acquiring_driver_and_ensure_status_fails_after_some_time(
     controller: adsimdetector.SimController,
 ):
@@ -87,9 +86,62 @@ async def test_start_acquiring_driver_and_ensure_status_fails_after_some_time(
 
     controller.frame_timeout = 0.1
 
-    acquiring = await controller.start_acquiring_driver_and_ensure_status()
+    acquiring = await controller.start_acquiring_driver_and_ensure_status(
+        start_timeout=0.2, state_timeout=0.2
+    )
 
     with pytest.raises(
         ValueError, match="Final detector state Disconnected not in valid end states:"
     ):
         await acquiring
+
+
+async def test_start_acquiring_driver_and_ensure_status_timing(
+    controller: adsimdetector.SimController,
+):
+    """This test ensures the camera has time to return to a good state.
+
+    Real world application; there is race condition wherein the
+    detector has been asked to complete acquisition, but has not yet
+    returned to a known good state before the status check.
+
+    """
+    set_mock_value(controller.driver.detector_state, adcore.ADState.ACQUIRE)
+
+    acquiring = await controller.start_acquiring_driver_and_ensure_status(
+        start_timeout=0.2, state_timeout=0.2
+    )
+
+    async def complete_acquire():
+        """Return to idle state, but pretend the detector is slow."""
+        await asyncio.sleep(0.05)
+        set_mock_value(controller.driver.detector_state, adcore.ADState.IDLE)
+
+    await asyncio.gather(acquiring, complete_acquire())
+
+
+async def bad_observe_value(*args, **kwargs):
+    "Stub to simulate a disconnected ``observe_value()``."
+    if True:
+        raise asyncio.TimeoutError()
+    yield None  # Make it a generator
+
+
+@patch("ophyd_async.epics.adcore._core_logic.observe_value", bad_observe_value)
+async def test_start_acquiring_driver_and_ensure_status_disconnected(
+    controller: adsimdetector.SimController,
+):
+    """This test ensures the function behaves gracefully if no detector
+    states are available.
+
+    """
+    acquiring = await controller.start_acquiring_driver_and_ensure_status(
+        start_timeout=0.2, state_timeout=0.2
+    )
+
+    with pytest.raises(asyncio.TimeoutError) as exc:
+        await acquiring
+    assert (
+        str(exc.value)
+        == "Could not monitor detector state: mock+ca://DRV:DetectorState_RBV"
+    )

{ophyd_async-0.10.0a4 → ophyd_async-0.10.1}/tests/epics/adcore/test_writers.py

@@ -296,3 +296,19 @@ async def test_nd_attributes_plan_stub_gives_correct_error(RE, detectors):
             == f"Invalid type for ndattributes: {type(invalidObjects[0])}. "
             + "Expected NDAttributePv or NDAttributeParam."
         )
+
+
+async def test_hdf_writer_descriptor_shape_contains_none(
+    hdf_writer: adcore.ADHDFWriter,
+):
+    async def shape_containing_none():
+        return 10, None, 10
+
+    hdf_writer._dataset_describer.shape = shape_containing_none
+
+    with pytest.raises(
+        ValueError,
+        match=r"Datasets with partially unknown dimensionality "
+        r"are not currently supported by ADHDFWriter.",
+    ):
+        await hdf_writer.open(DETECTOR_NAME)