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

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/.github/workflows/_test.yml

@@ -22,6 +22,11 @@ jobs:
     runs-on: ${{ inputs.runs-on }}
 
     steps:
+      - name: Set TEMP to D:/Temp
+        if: inputs.runs-on == 'windows-latest'
+        run: |
+          mkdir "D:\\Temp"
+          echo "TEMP=D:\\Temp" >> $env:GITHUB_ENV
       - name: Checkout
         uses: actions/checkout@v4
         with:
@@ -49,10 +54,15 @@ jobs:
         with:
           python-version: ${{ inputs.python-version }}
           pip-install: ".[dev]"
+          
+      - name: Run tests win
+        if: inputs.runs-on == 'windows-latest'
+        run: tox -e tests -- --timeout=6
 
-      - name: Run tests
-        run: tox -e tests
-
+      - name: Non win tests
+        if: inputs.runs-on != 'windows-latest'
+        run: tox -e tests -- --timeout=2
+      
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v4
         with:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a4
+Version: 0.11
 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
@@ -70,7 +70,7 @@ Requires-Dist: inflection; extra == "dev"
 Requires-Dist: import-linter; extra == "dev"
 Requires-Dist: myst-parser; extra == "dev"
 Requires-Dist: numpydoc; extra == "dev"
-Requires-Dist: ophyd; extra == "dev"
+Requires-Dist: ophyd>=1.10.7; extra == "dev"
 Requires-Dist: pickleshare; extra == "dev"
 Requires-Dist: pipdeptree; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/docs/explanations/devices-signals-backends.md

@@ -23,7 +23,7 @@ The `Device` class is the base of all ophyd-async objects that are published to
 - a [](#Device.parent) read-write property to read it's parent Device if it exists
 - a [](#Device.children) to iterate through the Device attributes, yielding the `(name, child)` child Devices
 - a `setattr` override that detects whether the attribute is also a Device and sets its parent
-- a [](#Device.set_name) method to set its name and also set the names of its children using the parent name as a prefix
+- a [](#Device.set_name) method to set its name and also set the names of its children using the parent name as a prefix, called at init and also when a new child is attached to an already named Device
 - a [](#Device.connect) method that connects it and its children
 
 All the above methods are concrete, but `connect()` calls out to a [](#DeviceConnector) to actually do the connection, only handling caching itself. This enables plug-in behavior on connect (like the introspection of child Attributes in Tango or PVI, or the special case for `Signal` we will see later).

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/docs/how-to/derive-one-signal-from-others.md

@@ -9,7 +9,7 @@ The simplest API involves mapping a single Derived Signal to many low level Sign
 - [`derived_signal_rw`](#ophyd_async.core.derived_signal_rw)
 - [`derived_signal_w`](#ophyd_async.core.derived_signal_w)
 
-If a signal is readable, then it requires a `raw_to_derived` function that maps the raw values of low level Signals into the datatype of the Derived Signal and the `raw_devices` that will be read/monitored to give those values.
+If a signal is readable, then it requires a `raw_to_derived` function that maps the raw values of low level Signals into the datatype of the Derived Signal and the `raw_devices_and_constants` that will be read/monitored to give those values.
 
 If a signal is writeable, then it requires a `set_derived` async function that sets the raw signals based on the derived value.
  
@@ -27,7 +27,7 @@ These examples show the low level Signals and Derived Signals in the same Device
 
 The more general API involves a two way mapping between many Derived Signals and many low level Signals. This is done by implementing a `Raw` [](#typing.TypedDict) subclass with the names and datatypes of the low level Signals, a `Derived` [](#typing.TypedDict) subclass with the names and datatypes of the derived Signals, and [](#Transform) class with `raw_to_derived` and `derived_to_raw` methods to convert between the two. Some transforms will also require parameters which get their values from other Signals for both methods. These should be put in as type hints on the `Transform` subclass.
 
-To create the derived signals, we make a [](#DerivedSignalFactory) instance that knows about the `Transform` class, the `raw_devices` that will be read/monitored to provide the raw values for the transform, and optionally the `set_derived` method to set them. The methods like [](#DerivedSignalFactory.derived_signal_rw) allow Derived signals to be created for each attribute in the `Derived` TypedDict subclass.
+To create the derived signals, we make a [](#DerivedSignalFactory) instance that knows about the `Transform` class, the `raw_devices_and_constants` that will be read/monitored to provide the raw values for the transform, and optionally the `set_derived` method to set them. The methods like [](#DerivedSignalFactory.derived_signal_rw) allow Derived signals to be created for each attribute in the `Derived` TypedDict subclass.
 
 In the below example we see this is action:
 

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/docs/tutorials/implementing-detectors.md

@@ -135,7 +135,7 @@ The above demonstrates the detector portion of a step scan, letting the things y
     @bpp.stage_decorator([bdet])
     @bpp.run_decorator()
     def fly_plan():
-        yield from bps.prepare(bdet, TriggerInfo(number_of_triggers=7), wait=True)
+        yield from bps.prepare(bdet, TriggerInfo(number_of_events=7), wait=True)
         yield from bps.declare_stream(bdet, name="primary")
         yield from bps.kickoff(bdet, wait=True)
         yield from bps.collect_while_completing(flyers=[bdet], dets=[bdet], flush_period=0.5)

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/docs/tutorials/implementing-devices.md

@@ -231,6 +231,7 @@ Finally, we need to communicate to bluesky that it has to `trigger()` and acquis
 
 Although the Signals are declared via type hints, the DeviceVector requires explicit instantiation in an `__init__` method. This is because it requires the `num_channels` to be passed in to the constructor to know how many channels require creation. This means that we also need to do the PV concatenation ourselves, so if the PV prefix for the device as `PREFIX:` then the first channel would have prefix `PREFIX:CHAN1:`. We also register them with `StandardReadable` in a different way, adding them within a [](#StandardReadable.add_children_as_readables) context manager which adds all the children created within its body.
 
+Whilst it is not required for the call to `super().__init__` to be after all signals have been created it is more efficient to do so. However, there may be some edge cases where signals need to be created after this e.g. for [derived signals](../how-to/derive-one-signal-from-others.md) that depend on their parent.
 :::
 
 :::{tab-item} Tango

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/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",
@@ -42,7 +42,7 @@ dev = [
     "import-linter",
     "myst-parser",
     "numpydoc",
-    "ophyd",
+    "ophyd>=1.10.7",
     "pickleshare",
     "pipdeptree",
     "pre-commit",
@@ -101,7 +101,7 @@ markers = [
 ]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
-
+timeout = 0.5
 [tool.coverage.run]
 data_file = "/tmp/ophyd_async.coverage"
 

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/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.11'
+__version_tuple__ = version_tuple = (0, 11)

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/src/ophyd_async/core/__init__.py

@@ -16,7 +16,7 @@ from ._detector import (
 )
 from ._device import Device, DeviceConnector, DeviceVector, init_devices
 from ._device_filler import DeviceFiller
-from ._flyer import FlyerController, StandardFlyer
+from ._flyer import FlyerController, FlyMotorInfo, StandardFlyer
 from ._hdf_dataset import HDFDatasetDescription, HDFDocumentComposer
 from ._log import config_ophyd_async_logging
 from ._mock_signal_backend import MockSignalBackend
@@ -56,11 +56,14 @@ from ._signal import (
     soft_signal_rw,
     wait_for_value,
     walk_config_signals,
+    walk_devices,
     walk_rw_signals,
+    walk_signal_sources,
 )
 from ._signal_backend import (
     Array1D,
     DTypeScalar_co,
+    Primitive,
     SignalBackend,
     SignalDatatype,
     SignalDatatypeT,
@@ -75,6 +78,7 @@ from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     Callback,
+    ConfinedModel,
     EnumTypes,
     LazyMock,
     NotConnected,
@@ -83,6 +87,7 @@ from ._utils import (
     SubsetEnum,
     SupersetEnum,
     WatcherUpdate,
+    error_if_none,
     gather_dict,
     get_dtype,
     get_enum_cls,
@@ -128,6 +133,7 @@ __all__ = [
     "EnumTypes",
     "Table",
     "SignalMetadata",
+    "Primitive",
     # Soft signal
     "SoftSignalBackend",
     "soft_signal_r_and_setter",
@@ -143,6 +149,8 @@ __all__ = [
     "set_and_wait_for_other_value",
     "walk_rw_signals",
     "walk_config_signals",
+    "walk_devices",
+    "walk_signal_sources",
     # Readable
     "StandardReadable",
     "StandardReadableFormat",
@@ -168,6 +176,7 @@ __all__ = [
     "HDFDocumentComposer",
     # Flyer
     "StandardFlyer",
+    "FlyMotorInfo",
     "FlyerController",
     # Settings
     "Settings",
@@ -179,8 +188,10 @@ __all__ = [
     "CalculatableTimeout",
     "DEFAULT_TIMEOUT",
     "Callback",
+    "ConfinedModel",
     "NotConnected",
     "Reference",
+    "error_if_none",
     "gather_dict",
     "get_dtype",
     "get_enum_cls",

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

@@ -11,7 +11,7 @@ from ._derived_signal_backend import (
 )
 from ._device import Device
 from ._signal import Signal, SignalR, SignalRW, SignalT, SignalW
-from ._signal_backend import SignalDatatypeT
+from ._signal_backend import Primitive, SignalDatatypeT
 
 
 class DerivedSignalFactory(Generic[TransformT]):
@@ -23,18 +23,31 @@ class DerivedSignalFactory(Generic[TransformT]):
     :param set_derived:
         An optional async function that takes the output of
         `transform_cls.raw_to_derived` and applies it to the raw devices.
-    :param raw_and_transform_devices:
-        Devices whose values will be passed as parameters to the `transform_cls`,
-        and as arguments to `transform_cls.raw_to_derived`.
+    :param raw_and_transform_devices_and_constants:
+        Devices and Constants whose values will be passed as parameters
+        to the `transform_cls`, and as arguments to `transform_cls.raw_to_derived`.
     """
 
     def __init__(
         self,
         transform_cls: type[TransformT],
         set_derived: Callable[..., Awaitable[None]] | None = None,
-        **raw_and_transform_devices,
+        **raw_and_transform_devices_and_constants,
     ):
         self._set_derived = set_derived
+        _raw_and_transform_devices, _raw_and_transform_constants = (
+            {
+                k: v
+                for k, v in raw_and_transform_devices_and_constants.items()
+                if isinstance(v, Device)
+            },
+            {
+                k: v
+                for k, v in raw_and_transform_devices_and_constants.items()
+                if isinstance(v, Primitive)
+            },
+        )
+
         # Check the raw and transform devices match the input arguments of the Transform
         if transform_cls is not Transform:
             # Populate expected parameters and types
@@ -48,26 +61,42 @@ class DerivedSignalFactory(Generic[TransformT]):
             }
 
             # Populate received parameters and types
-            # Use Signal datatype, or Locatable datatype, or set type as None
+            # Use Primitive's type, Signal's datatype,
+            # Locatable's datatype, or set type as None
             received = {
-                k: v.datatype if isinstance(v, Signal) else get_locatable_type(v)
-                for k, v in raw_and_transform_devices.items()
+                **{
+                    k: v.datatype if isinstance(v, Signal) else get_locatable_type(v)
+                    for k, v in _raw_and_transform_devices.items()
+                },
+                **{k: type(v) for k, v in _raw_and_transform_constants.items()},
             }
 
             if expected != received:
                 msg = (
-                    f"Expected devices to be passed as keyword arguments "
+                    f"Expected the following to be passed as keyword arguments "
                     f"{expected}, got {received}"
                 )
                 raise TypeError(msg)
         self._set_derived_takes_dict = (
             is_typeddict(_get_first_arg_datatype(set_derived)) if set_derived else False
         )
+
+        _raw_constants, _transform_constants = _partition_by_keys(
+            _raw_and_transform_constants, set(transform_cls.model_fields)
+        )
+
+        _raw_devices, _transform_devices = _partition_by_keys(
+            _raw_and_transform_devices, set(transform_cls.model_fields)
+        )
+
         self._transformer = SignalTransformer(
             transform_cls,
             set_derived,
             self._set_derived_takes_dict,
-            **raw_and_transform_devices,
+            _raw_devices,
+            _raw_constants,
+            _transform_devices,
+            _transform_constants,
         )
 
     def _make_signal(
@@ -177,7 +206,7 @@ def _get_first_arg_datatype(
 def _make_factory(
     raw_to_derived: Callable[..., SignalDatatypeT] | None = None,
     set_derived: Callable[[SignalDatatypeT], Awaitable[None]] | None = None,
-    raw_devices: dict[str, Device] | None = None,
+    raw_devices_and_constants: dict[str, Device | Primitive] | None = None,
 ) -> DerivedSignalFactory:
     if raw_to_derived:
 
@@ -190,7 +219,9 @@ def _make_factory(
         DerivedTransform.raw_to_derived.__annotations__ = get_type_hints(raw_to_derived)
 
         return DerivedSignalFactory(
-            DerivedTransform, set_derived=set_derived, **(raw_devices or {})
+            DerivedTransform,
+            set_derived=set_derived,
+            **(raw_devices_and_constants or {}),
         )
     else:
         return DerivedSignalFactory(Transform, set_derived=set_derived)
@@ -200,7 +231,7 @@ def derived_signal_r(
     raw_to_derived: Callable[..., SignalDatatypeT],
     derived_units: str | None = None,
     derived_precision: int | None = None,
-    **raw_devices: Device,
+    **raw_devices_and_constants: Device | Primitive,
 ) -> SignalR[SignalDatatypeT]:
     """Create a read only derived signal.
 
@@ -209,11 +240,14 @@ def derived_signal_r(
         returns the derived value.
     :param derived_units: Engineering units for the derived signal
     :param derived_precision: Number of digits after the decimal place to display
-    :param raw_devices:
-        A dictionary of Devices to provide the values for raw_to_derived. The names
-        of these arguments must match the arguments of raw_to_derived.
+    :param raw_devices_and_constants:
+        A dictionary of Devices and Constants to provide the values for raw_to_derived.
+        The names of these arguments must match the arguments of raw_to_derived.
     """
-    factory = _make_factory(raw_to_derived=raw_to_derived, raw_devices=raw_devices)
+    factory = _make_factory(
+        raw_to_derived=raw_to_derived,
+        raw_devices_and_constants=raw_devices_and_constants,
+    )
     return factory.derived_signal_r(
         datatype=_get_return_datatype(raw_to_derived),
         name="value",
@@ -227,7 +261,7 @@ def derived_signal_rw(
     set_derived: Callable[[SignalDatatypeT], Awaitable[None]],
     derived_units: str | None = None,
     derived_precision: int | None = None,
-    **raw_devices: Device,
+    **raw_devices_and_constants: Device | Primitive,
 ) -> SignalRW[SignalDatatypeT]:
     """Create a read-write derived signal.
 
@@ -239,21 +273,23 @@ def derived_signal_rw(
         either be an async function, or return an [](#AsyncStatus)
     :param derived_units: Engineering units for the derived signal
     :param derived_precision: Number of digits after the decimal place to display
-    :param raw_devices:
-        A dictionary of Devices to provide the values for raw_to_derived. The names
-        of these arguments must match the arguments of raw_to_derived.
+    :param raw_devices_and_constants:
+        A dictionary of Devices and Constants to provide the values for raw_to_derived.
+        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:
         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)
 
     factory = _make_factory(
-        raw_to_derived=raw_to_derived, set_derived=set_derived, raw_devices=raw_devices
+        raw_to_derived=raw_to_derived,
+        set_derived=set_derived,
+        raw_devices_and_constants=raw_devices_and_constants,
     )
     return factory.derived_signal_rw(
         datatype=raw_to_derived_datatype,
@@ -297,3 +333,13 @@ def get_locatable_type(obj: object) -> type | None:
             if args:
                 return args[0]
     return None
+
+
+def _partition_by_keys(data: dict, keys: set) -> tuple[dict, dict]:
+    group_excluded, group_included = {}, {}
+    for k, v in data.items():
+        if k in keys:
+            group_included[k] = v
+        else:
+            group_excluded[k] = v
+    return group_excluded, group_included

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

@@ -7,17 +7,23 @@ from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
 from bluesky.protocols import Location, Reading, Subscribable
 from event_model import DataKey
-from pydantic import BaseModel
 
 from ._protocol import AsyncLocatable, AsyncReadable
 from ._signal_backend import SignalBackend, SignalDatatypeT, make_datakey, make_metadata
-from ._utils import Callback, T, gather_dict, merge_gathered_dicts
+from ._utils import (
+    Callback,
+    ConfinedModel,
+    T,
+    error_if_none,
+    gather_dict,
+    merge_gathered_dicts,
+)
 
 RawT = TypeVar("RawT")
 DerivedT = TypeVar("DerivedT")
 
 
-class Transform(BaseModel, Generic[RawT, DerivedT]):
+class Transform(ConfinedModel, Generic[RawT, DerivedT]):
     """Baseclass for bidirectional transforms for Derived Signals.
 
     Subclass and add:
@@ -61,7 +67,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_):
@@ -77,35 +83,42 @@ class SignalTransformer(Generic[TransformT]):
         transform_cls: type[TransformT],
         set_derived: Callable[..., Awaitable[None]] | None,
         set_derived_takes_dict: bool,
-        **raw_and_transform_devices,
+        raw_devices,
+        raw_constants,
+        transform_devices,
+        transform_constants,
     ):
         self._transform_cls = transform_cls
         self._set_derived = set_derived
         self._set_derived_takes_dict = set_derived_takes_dict
-        self._transform_devices = {
-            k: raw_and_transform_devices.pop(k) for k in transform_cls.model_fields
-        }
-        self._raw_devices = raw_and_transform_devices
+
+        self._transform_devices = transform_devices
+        self._transform_constants = transform_constants
+        self._raw_devices = raw_devices
+        self._raw_constants = raw_constants
+
         self._derived_callbacks: dict[str, Callback[Reading]] = {}
         self._cached_readings: dict[str, Reading] | None = None
 
     @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(
@@ -122,7 +135,7 @@ class SignalTransformer(Generic[TransformT]):
             k: transform_readings[sig.name]["value"]
             for k, sig in self.transform_readables.items()
         }
-        return self._transform_cls(**transform_args)
+        return self._transform_cls(**(transform_args | self._transform_constants))
 
     def _make_derived_readings(
         self, raw_and_transform_readings: dict[str, Reading]
@@ -140,10 +153,15 @@ class SignalTransformer(Generic[TransformT]):
         transform = self._make_transform_from_readings(raw_and_transform_readings)
         # Create the raw values from the rest then calculate the derived readings
         # using the transform
+        # Extend dictionary with values of any Constants passed as arguments
         raw_values = {
-            k: raw_and_transform_readings[sig.name]["value"]
-            for k, sig in self._raw_devices.items()
+            **{
+                k: raw_and_transform_readings[sig.name]["value"]
+                for k, sig in self._raw_devices.items()
+            },
+            **self._raw_constants,
         }
+
         derived_readings = {
             name: Reading(
                 value=derived, timestamp=timestamp, alarm_severity=alarm_severity
@@ -173,13 +191,15 @@ class SignalTransformer(Generic[TransformT]):
         return {k: v["value"] for k, v in derived_readings.items()}
 
     def _update_cached_reading(self, value: dict[str, Reading]):
-        if self._cached_readings is None:
-            msg = "Cannot update cached reading as it has not been initialised"
-            raise RuntimeError(msg)
-        self._cached_readings.update(value)
+        _cached_readings = error_if_none(
+            self._cached_readings,
+            "Cannot update cached reading as it has not been initialised",
+        )
+
+        _cached_readings.update(value)
         if self._complete_cached_reading():
             # We've got a complete set of values, callback on them
-            derived_readings = self._make_derived_readings(self._cached_readings)
+            derived_readings = self._make_derived_readings(_cached_readings)
             for name, callback in self._derived_callbacks.items():
                 callback(derived_readings[name])
 
@@ -226,18 +246,19 @@ class SignalTransformer(Generic[TransformT]):
         }
 
     async def set_derived(self, name: str, value: Any):
-        if self._set_derived is None:
-            msg = "Cannot put as no set_derived method given"
-            raise RuntimeError(msg)
+        _set_derived = error_if_none(
+            self._set_derived,
+            "Cannot put as no set_derived method given",
+        )
         if self._set_derived_takes_dict:
             # Need to get the other derived values and update the one that's changing
             derived = await self.get_locations()
             setpoints = {k: v["setpoint"] for k, v in derived.items()}
             setpoints[name] = value
-            await self._set_derived(setpoints)
+            await _set_derived(setpoints)
         else:
             # Only one derived signal, so pass it directly
-            await self._set_derived(value)
+            await _set_derived(value)
 
 
 class DerivedSignalBackend(SignalBackend[SignalDatatypeT]):
@@ -273,9 +294,12 @@ class DerivedSignalBackend(SignalBackend[SignalDatatypeT]):
         if wait is False:
             msg = "Cannot put with wait=False"
             raise RuntimeError(msg)
-        if value is None:
-            msg = "Must be given a value to put"
-            raise RuntimeError(msg)
+
+        value = error_if_none(
+            value,
+            "Must be given a value to put",
+        )
+
         await self.transformer.set_derived(self.name, value)
 
     async def get_datakey(self, source: str) -> DataKey:

{ophyd_async-0.10.0a4 → ophyd_async-0.11}/src/ophyd_async/core/_detector.py

@@ -23,13 +23,13 @@ from bluesky.protocols import (
     WritesStreamAssets,
 )
 from event_model import DataKey
-from pydantic import BaseModel, Field, NonNegativeInt, PositiveInt, computed_field
+from pydantic import Field, NonNegativeInt, PositiveInt, computed_field
 
 from ._device import Device, DeviceConnector
 from ._protocol import AsyncConfigurable, AsyncReadable
 from ._signal import SignalR
 from ._status import AsyncStatus, WatchableAsyncStatus
-from ._utils import DEFAULT_TIMEOUT, WatcherUpdate, merge_gathered_dicts
+from ._utils import DEFAULT_TIMEOUT, ConfinedModel, WatcherUpdate, merge_gathered_dicts
 
 
 class DetectorTrigger(Enum):
@@ -48,7 +48,7 @@ class DetectorTrigger(Enum):
     """Expect a series of variable width external gate signals"""
 
 
-class TriggerInfo(BaseModel):
+class TriggerInfo(ConfinedModel):
     """Minimal set of information required to setup triggering on a detector."""
 
     number_of_events: NonNegativeInt | list[NonNegativeInt] = Field(default=1)