ophyd-async 0.10.0a1__tar.gz → 0.10.0a2__tar.gz

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a1
+Version: 0.10.0a2
 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.10.0a1 → ophyd_async-0.10.0a2}/src/ophyd_async/_version.py

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

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a2}/src/ophyd_async/core/_derived_signal.py

@@ -173,7 +173,7 @@ def _make_factory(
 
         # 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__ = raw_to_derived.__annotations__
+        DerivedTransform.raw_to_derived.__annotations__ = get_type_hints(raw_to_derived)
 
         return DerivedSignalFactory(
             DerivedTransform, set_derived=set_derived, **(raw_devices or {})

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a2}/src/ophyd_async/core/_table.py

@@ -93,18 +93,19 @@ class Table(BaseModel):
 
     def __add__(self, right: TableSubclass) -> TableSubclass:
         """Concatenate the arrays in field values."""
-        if type(right) is not type(self):
+        cls = type(right)
+        if type(self) is not cls:
             raise RuntimeError(
                 f"{right} is not a `Table`, or is not the same "
                 f"type of `Table` as {self}."
             )
 
-        return type(right)(
+        return cls(
             **{
                 field_name: _concat(
                     getattr(self, field_name), getattr(right, field_name)
                 )
-                for field_name in self.model_fields
+                for field_name in cls.model_fields
             }
         )
 

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a2}/src/ophyd_async/testing/_assert.py

@@ -1,6 +1,7 @@
 import asyncio
+from collections.abc import Mapping
 from contextlib import AbstractContextManager
-from typing import Any
+from typing import Any, cast
 from unittest.mock import Mock, call
 
 import pytest
@@ -43,7 +44,7 @@ async def assert_value(signal: SignalR[SignalDatatypeT], value: Any) -> None:
 
 async def assert_reading(
     readable: AsyncReadable,
-    expected_reading: dict[str, dict[str, Any]],
+    expected_reading: Mapping[str, Mapping[str, Any]],
 ) -> None:
     """Assert that a readable Device has the given reading.
 
@@ -54,20 +55,25 @@ async def assert_reading(
     _assert_readings_approx_equal(expected_reading, actual_reading)
 
 
-def _assert_readings_approx_equal(expected, actual):
-    assert expected.keys() == actual.keys()
-    approx_expected_reading = {
-        k: dict(
-            v,
-            value=approx_value(v["value"]),
-            timestamp=pytest.approx(v["timestamp"], rel=0.1)
-            if "timestamp" in v
-            else actual[k]["timestamp"],
-            alarm_severity=v.get("alarm_severity", actual[k]["alarm_severity"]),
-        )
-        for k, v in expected.items()
+def _approx_reading(expected: Mapping[str, Any], actual: Reading) -> Reading:
+    ret = dict(
+        expected,
+        value=approx_value(expected["value"]),
+        timestamp=pytest.approx(expected["timestamp"], rel=0.1)
+        if "timestamp" in expected
+        else actual["timestamp"],
+    )
+    if "alarm_severity" in actual and "alarm_severity" not in expected:
+        ret["alarm_severity"] = actual["alarm_severity"]
+    return cast(Reading, ret)
+
+
+def _assert_readings_approx_equal(
+    expected: Mapping[str, Mapping[str, Any]], actual: Mapping[str, Reading]
+):
+    assert actual == {
+        k: _approx_reading(v, actual[k]) for k, v in expected.items() if k in actual
     }
-    assert actual == approx_expected_reading
 
 
 async def assert_configuration(

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a2}/src/ophyd_async/testing/_single_derived.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 
 from ophyd_async.core import (

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a2}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a1
+Version: 0.10.0a2
 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.10.0a1 → ophyd_async-0.10.0a2}/tests/core/test_signal.py

@@ -10,9 +10,12 @@ import numpy as np
 import numpy.typing as npt
 import pytest
 from bluesky.protocols import Reading
+from event_model import DataKey
 
 from ophyd_async.core import (
     Array1D,
+    AsyncReadable,
+    Device,
     SignalR,
     SignalRW,
     SoftSignalBackend,
@@ -801,6 +804,17 @@ async def test_failed_assert_reading(
         await assert_reading(mock_readable, dummy_reading)
 
 
+async def test_assert_reading_without_severity():
+    class Thing(Device, AsyncReadable):
+        async def describe(self) -> dict[str, DataKey]:
+            return {}
+
+        async def read(self) -> dict[str, Reading]:
+            return {"foo": {"value": 42, "timestamp": 0.1}}
+
+    await assert_reading(Thing(), {"foo": {"value": 42}})
+
+
 async def test_assert_configuration(mock_readable: DummyReadableArray):
     set_mock_value(mock_readable.str_value, "haha")
     set_mock_value(mock_readable.strictEnum_value, MockEnum.GOOD)