ophyd-async 0.14.1__tar.gz → 0.14.2__tar.gz

{ophyd_async-0.14.1/src/ophyd_async.egg-info → ophyd_async-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.14.1
+Version: 0.14.2
 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

{ophyd_async-0.14.1 → ophyd_async-0.14.2}/src/ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.14.1'
-__version_tuple__ = version_tuple = (0, 14, 1)
+__version__ = version = '0.14.2'
+__version_tuple__ = version_tuple = (0, 14, 2)
 
-__commit_id__ = commit_id = 'g9b567b214'
+__commit_id__ = commit_id = 'ga221add53'

{ophyd_async-0.14.1 → ophyd_async-0.14.2}/src/ophyd_async/core/_derived_signal.py

@@ -1,5 +1,15 @@
-from collections.abc import Awaitable, Callable
-from typing import Any, Generic, get_args, get_origin, get_type_hints, is_typeddict
+import functools
+from collections.abc import Awaitable, Callable, Mapping
+from inspect import Parameter, signature
+from typing import (
+    Any,
+    Generic,
+    TypeVar,
+    get_args,
+    get_origin,
+    get_type_hints,
+    is_typeddict,
+)
 
 from bluesky.protocols import Locatable
 
@@ -53,12 +63,13 @@ class DerivedSignalFactory(Generic[TransformT]):
             # Populate expected parameters and types
             expected = {
                 **{k: f.annotation for k, f in transform_cls.model_fields.items()},
-                **{
-                    k: v
-                    for k, v in get_type_hints(transform_cls.raw_to_derived).items()
-                    if k not in {"self", "return"}
-                },
+                **_get_params_types_dict(transform_cls.raw_to_derived),
             }
+            if empty_keys := [k for k, v in expected.items() if v == Parameter.empty]:
+                raise TypeError(
+                    f"{transform_cls.raw_to_derived} is missing a type "
+                    f"hint for arguments: {empty_keys}"
+                )
 
             # Populate received parameters and types
             # Use Primitive's type, Signal's datatype,
@@ -76,7 +87,19 @@ class DerivedSignalFactory(Generic[TransformT]):
                     f"Expected the following to be passed as keyword arguments "
                     f"{expected}, got {received}"
                 )
-                raise TypeError(msg)
+                if set(expected.keys()) - set(received.keys()):
+                    raise TypeError(msg)
+
+                for k in set(expected.keys()):
+                    if isinstance(expected[k], type):
+                        if not issubclass(received[k], expected[k]):
+                            raise TypeError(msg)
+                    elif isinstance(expected[k], TypeVar):
+                        bound = expected[k].__bound__
+                        if isinstance(bound, type) and not issubclass(
+                            received[k], bound
+                        ):
+                            raise TypeError(msg)
         self._set_derived_takes_dict = (
             is_typeddict(_get_first_arg_datatype(set_derived)) if set_derived else False
         )
@@ -195,28 +218,28 @@ def _get_return_datatype(func: Callable[..., SignalDatatypeT]) -> type[SignalDat
 def _get_first_arg_datatype(
     func: Callable[[SignalDatatypeT], Any],
 ) -> type[SignalDatatypeT]:
-    args = get_type_hints(func)
-    args.pop("return", None)
+    args = _get_params_types_dict(func)
     if not args:
         msg = f"{func} does not have a type hinted argument"
         raise TypeError(msg)
     return list(args.values())[0]
 
 
+def _get_params_types_dict(inspected_function: Callable) -> Mapping[str, Any]:
+    sig = signature(inspected_function, eval_str=True)
+    exclude_keys = {"self", "args", "kwargs", "cls"}
+    return {k: v.annotation for k, v in sig.parameters.items() if k not in exclude_keys}
+
+
 def _make_factory(
-    raw_to_derived: Callable[..., SignalDatatypeT] | None = None,
+    raw_to_derived_func: Callable[..., SignalDatatypeT] | None = None,
     set_derived: Callable[[SignalDatatypeT], Awaitable[None]] | None = None,
     raw_devices_and_constants: dict[str, Device | Primitive] | None = None,
 ) -> DerivedSignalFactory:
-    if raw_to_derived:
+    if raw_to_derived_func:
 
         class DerivedTransform(Transform):
-            def raw_to_derived(self, **kwargs) -> dict[str, SignalDatatypeT]:
-                return {"value": raw_to_derived(**kwargs)}
-
-        # Update the signature for raw_to_derived to match what we are passed as this
-        # will be checked in DerivedSignalFactory
-        DerivedTransform.raw_to_derived.__annotations__ = get_type_hints(raw_to_derived)
+            raw_to_derived = _dict_wrapper(raw_to_derived_func)
 
         return DerivedSignalFactory(
             DerivedTransform,
@@ -245,7 +268,7 @@ def derived_signal_r(
         The names of these arguments must match the arguments of raw_to_derived.
     """
     factory = _make_factory(
-        raw_to_derived=raw_to_derived,
+        raw_to_derived_func=raw_to_derived,
         raw_devices_and_constants=raw_devices_and_constants,
     )
     return factory.derived_signal_r(
@@ -278,16 +301,16 @@ def derived_signal_rw(
         The names of these arguments must match the arguments of raw_to_derived.
     """
     raw_to_derived_datatype = _get_return_datatype(raw_to_derived)
-    set_derived_datatype = _get_first_arg_datatype(set_derived)
-    if raw_to_derived_datatype != set_derived_datatype:
+    set_derived_arg_datatype = _get_first_arg_datatype(set_derived)
+    if raw_to_derived_datatype != set_derived_arg_datatype:
         msg = (
             f"{raw_to_derived} has datatype {raw_to_derived_datatype} "
-            f"!= {set_derived_datatype} datatype {set_derived_datatype}"
+            f"!= {set_derived_arg_datatype} datatype {set_derived_arg_datatype}"
         )
         raise TypeError(msg)
 
     factory = _make_factory(
-        raw_to_derived=raw_to_derived,
+        raw_to_derived_func=raw_to_derived,
         set_derived=set_derived,
         raw_devices_and_constants=raw_devices_and_constants,
     )
@@ -343,3 +366,13 @@ def _partition_by_keys(data: dict, keys: set) -> tuple[dict, dict]:
         else:
             group_excluded[k] = v
     return group_excluded, group_included
+
+
+def _dict_wrapper(
+    fn: Callable[..., SignalDatatypeT],
+) -> Callable[..., dict[str, SignalDatatypeT]]:
+    @functools.wraps(fn)
+    def wrapped(self, **kwargs):
+        return {"value": fn(**kwargs)}
+
+    return wrapped

{ophyd_async-0.14.1 → ophyd_async-0.14.2}/src/ophyd_async/core/_device_filler.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import types
 from abc import abstractmethod
 from collections.abc import Callable, Iterator, Sequence
 from typing import (
@@ -9,8 +10,10 @@ from typing import (
     NoReturn,
     Protocol,
     TypeVar,
+    Union,
     cast,
     get_args,
+    get_origin,
     get_type_hints,
     runtime_checkable,
 )
@@ -76,6 +79,7 @@ class DeviceFiller(Generic[SignalBackendT, DeviceConnectorT]):
         self._extras: dict[UniqueName, Sequence[Any]] = {}
         self._signal_datatype: dict[LogicalName, type | None] = {}
         self._vector_device_type: dict[LogicalName, type[Device] | None] = {}
+        self._optional_devices: set[str] = set()
         self.ignored_signals: set[str] = set()
         # Backends and Connectors stored ready for the connection phase
         self._unfilled_backends: dict[
@@ -121,6 +125,20 @@ class DeviceFiller(Generic[SignalBackendT, DeviceConnectorT]):
                 self.ignored_signals.add(attr_name)
             name = UniqueName(attr_name)
             origin = get_origin_class(annotation)
+            args = get_args(annotation)
+
+            if (
+                get_origin(annotation) is Union
+                and types.NoneType in args
+                and len(args) == 2
+            ):
+                # Annotation is an Union with two arguments, one of which is None
+                # Make this signal an optional parameter and set origin to T
+                # so the device is added to unfilled_connectors
+                self._optional_devices.add(name)
+                (annotation,) = [x for x in args if x is not types.NoneType]
+                origin = get_origin_class(annotation)
+
             if (
                 name == "parent"
                 or name.startswith("_")
@@ -241,10 +259,17 @@ class DeviceFiller(Generic[SignalBackendT, DeviceConnectorT]):
         :param source: The source of the data that should have done the filling, for
                        reporting as an error message
         """
-        unfilled = sorted(set(self._unfilled_connectors).union(self._unfilled_backends))
-        if unfilled:
+        unfilled = set(self._unfilled_connectors).union(self._unfilled_backends)
+        unfilled_optional = sorted(unfilled.intersection(self._optional_devices))
+
+        for name in unfilled_optional:
+            setattr(self._device, name, None)
+
+        required = sorted(unfilled.difference(unfilled_optional))
+
+        if required:
             raise RuntimeError(
-                f"{self._device.name}: cannot provision {unfilled} from {source}"
+                f"{self._device.name}: cannot provision {required} from {source}"
             )
 
     def _ensure_device_vector(self, name: LogicalName) -> DeviceVector:

{ophyd_async-0.14.1 → ophyd_async-0.14.2/src/ophyd_async.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.14.1
+Version: 0.14.2
 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

{ophyd_async-0.14.1 → ophyd_async-0.14.2}/tests/unit_tests/core/test_device.py

@@ -8,6 +8,7 @@ import pytest
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     Device,
+    DeviceFiller,
     DeviceVector,
     NotConnectedError,
     Reference,
@@ -266,3 +267,50 @@ def test_setitem_with_non_device_value():
     device_vector = DeviceVector(children={})
     with pytest.raises(TypeError, match="Expected Device, got"):
         device_vector[1] = "not_a_device"
+
+
+def test_device_filler_check_filled_with_optional_signals():
+    """Test DeviceFiller.check_filled with both mandatory and optional Signals."""
+
+    class TestDevice(Device):
+        mandatory_signal: SignalRW[int]
+        optional_signal: SignalRW[int] | None
+
+    # Create a mock backend factory
+    def mock_backend_factory(datatype):
+        backend = Mock()
+        backend.datatype = datatype
+        return backend
+
+    # Create a mock connector factory
+    def mock_connector_factory():
+        return Mock()
+
+    device = TestDevice()
+    filler = DeviceFiller(
+        device=device,
+        signal_backend_factory=mock_backend_factory,
+        device_connector_factory=mock_connector_factory,
+    )
+
+    # Create signals from annotations (unfilled)
+    list(filler.create_signals_from_annotations(filled=False))
+
+    assert hasattr(device, "optional_signal")
+    assert isinstance(device.optional_signal, SignalRW)
+
+    # Test failure path: check_filled should fail when mandatory signal is unfilled
+    with pytest.raises(RuntimeError, match="cannot provision.*mandatory_signal"):
+        filler.check_filled("test_source")
+
+    # Fill the mandatory signal
+    filler.fill_child_signal("mandatory_signal", SignalRW, None)
+
+    # Test success path: check_filled should succeed and set optional_signal to None
+    filler.check_filled("test_source")
+
+    # Verify mandatory signal exists and optional signal is None
+    assert hasattr(device, "mandatory_signal")
+    assert isinstance(device.mandatory_signal, SignalRW)
+    assert hasattr(device, "optional_signal")
+    assert device.optional_signal is None

{ophyd_async-0.14.1 → ophyd_async-0.14.2}/tests/unit_tests/core/test_multi_derived_signal.py

@@ -1,6 +1,7 @@
 import asyncio
 import math
 import re
+from typing import TypeVar
 from unittest.mock import ANY, call
 
 import pytest
@@ -8,8 +9,12 @@ from bluesky.protocols import Reading
 
 from ophyd_async.core import (
     DerivedSignalFactory,
+    EnableDisable,
+    EnumTypes,
     SignalRW,
+    StrictEnum,
     Table,
+    Transform,
     derived_signal_rw,
     get_mock,
     set_mock_value,
@@ -187,3 +192,60 @@ def test_make_rw_signal_type_mismatch():
         match=re.escape("Must define a set_derived method to support derived"),
     ):
         factory.derived_signal_rw(datatype=Table, name="")
+
+
+def test_missing_type_hint_in_raw_to_derived_transform():
+    class UnTypedTransform(Transform):
+        def raw_to_derived(self, x) -> float:
+            return x
+
+    with pytest.raises(
+        TypeError,
+        match=re.escape(" is missing a type hint for arguments: ['x']"),
+    ):
+        DerivedSignalFactory(
+            UnTypedTransform,
+            set_derived=None,
+            x=soft_signal_rw(float),
+        )
+
+
+def test_sub_type_hint_in_raw_to_derived_transform():
+    class SubTypedTransform(Transform):
+        def raw_to_derived(self, x: StrictEnum) -> StrictEnum:
+            return x
+
+    DerivedSignalFactory(
+        SubTypedTransform,
+        set_derived=None,
+        x=soft_signal_rw(EnableDisable),
+    )
+
+    with pytest.raises(
+        TypeError,
+        match=re.escape(
+            "Expected the following to be passed as keyword arguments "
+            "{'x': <enum 'StrictEnum'>}, "
+            "got {'x': <class 'float'>}"
+        ),
+    ):
+        DerivedSignalFactory(
+            SubTypedTransform,
+            set_derived=None,
+            x=soft_signal_rw(float),
+        )
+
+
+EnumTypesT = TypeVar("EnumTypesT", bound=EnumTypes)
+
+
+def test_protocol_type_hint_in_raw_to_derived_transform():
+    class SubTypedTransform(Transform):
+        def raw_to_derived(self, x: EnumTypesT) -> EnumTypesT:
+            return x
+
+    DerivedSignalFactory(
+        SubTypedTransform,
+        set_derived=None,
+        x=soft_signal_rw(EnableDisable),
+    )

{ophyd_async-0.14.1 → ophyd_async-0.14.2}/tests/unit_tests/core/test_observe.py

@@ -113,17 +113,21 @@ async def test_observe_value_times_out_with_no_external_task():
 
     recv = []
 
+    start = time.monotonic()
+
     async def watch(done_timeout):
         async for val in observe_value(sig, done_timeout=done_timeout):
-            recv.append(val)
+            recv.append(time.monotonic() - start)
             setter(val + 1)
 
-    start = time.monotonic()
     with pytest.raises(asyncio.TimeoutError):
-        await watch(done_timeout=0.1)
+        await watch(done_timeout=0.07)
     # On a dev machine we can do >200 iterations in 0.1s, but CI is slower
     assert len(recv) > 10
-    assert time.monotonic() - start == pytest.approx(0.1, abs=0.05)
+    elapsed = time.monotonic() - start
+    assert elapsed == pytest.approx(0.07, abs=0.05), (
+        f"Elapsed: {elapsed} Received: {recv}"
+    )
 
 
 async def test_observe_value_uses_correct_timeout():

{ophyd_async-0.14.1 → ophyd_async-0.14.2}/tests/unit_tests/core/test_single_derived_signal.py

@@ -88,7 +88,7 @@ async def test_get_returns_right_position(
 
 @pytest.mark.parametrize("cls", [ReadOnlyBeamstop, MovableBeamstop])
 async def test_monitoring_position(cls: type[ReadOnlyBeamstop | MovableBeamstop]):
-    results = asyncio.Queue[BeamstopPosition]()
+    results: asyncio.Queue[dict[str, Reading]] = asyncio.Queue()
     inst = cls("inst")
     inst.position.subscribe_reading(results.put_nowait)
     assert (await results.get())["inst-position"][
@@ -181,6 +181,29 @@ async def _put(value: float) -> None:
     pass
 
 
+# function without type hint on first argument
+def _get_no_type(ts) -> float:
+    return ts
+
+
+async def test_derived_signal_rw_get_method_no_param_type():
+    signal_rw = soft_signal_rw(int, initial_value=4)
+    with pytest.raises(
+        TypeError,
+        match=re.escape(" is missing a type hint for arguments: ['ts']"),
+    ):
+        derived_signal_rw(_get_no_type, _put, ts=signal_rw)
+
+
+async def test_derived_signal_r_get_method_no_param_type():
+    signal_rw = soft_signal_rw(int, initial_value=4)
+    with pytest.raises(
+        TypeError,
+        match=re.escape(" is missing a type hint for arguments: ['ts']"),
+    ):
+        derived_signal_r(_get_no_type, ts=signal_rw)
+
+
 @pytest.fixture
 def derived_signal_backend() -> SignalBackend[SignalDatatype]:
     signal_rw = soft_signal_rw(int, initial_value=4)

{ophyd_async-0.14.1 → ophyd_async-0.14.2}/tests/unit_tests/epics/pvi/test_pvi.py

@@ -52,6 +52,10 @@ class Block4(StandardReadable):
     signal_rw: SignalRW[int]
 
 
+class Block5(Device):
+    signal_rw: SignalRW[int] | None
+
+
 DeviceT = TypeVar("DeviceT", bound=Device)
 
 
@@ -133,6 +137,19 @@ async def test_device_create_children_from_annotations():
     assert device.signal_device is top_block_1_device
 
 
+async def test_device_create_device_with_optional_signals():
+    device = with_pvi_connector(Block5, "PREFIX:")
+
+    # Makes sure before connecting we create a signal and it exists in the device
+    assert hasattr(device, "signal_rw")
+    assert isinstance(device.signal_rw, SignalRW)
+
+    await device.connect(mock=True)
+
+    # After connecting if the optional signal is not filled it's set to None
+    assert isinstance(device.signal_rw, SignalRW)
+
+
 async def test_device_create_children_from_annotations_with_device_vectors():
     device = with_pvi_connector(Block4, "PREFIX:", name="test_device")
     await device.connect(mock=True)