bec-lib 4.4.0__tar.gz → 4.4.2__tar.gz

{bec_lib-4.4.0 → bec_lib-4.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec_lib
-Version: 4.4.0
+Version: 4.4.2
 Summary: BEC library
 Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
 Project-URL: Homepage, https://github.com/bec-project/bec

{bec_lib-4.4.0 → bec_lib-4.4.2}/bec_lib/codecs.py

@@ -10,7 +10,7 @@ from pydantic import BaseModel
 from bec_lib import messages as messages_module
 from bec_lib import numpy_encoder
 from bec_lib.device import DeviceBase
-from bec_lib.endpoints import EndpointInfo
+from bec_lib.endpoints import EndpointInfo, MessageOp
 from bec_lib.messages import BECMessage, BECStatus
 
 
@@ -126,7 +126,7 @@ class EndpointInfoEncoder(BECCodec):
         return EndpointInfo(
             endpoint=data["endpoint"],
             message_type=getattr(messages_module, data["message_type"]),
-            message_op=data["message_op"],
+            message_op=MessageOp(data["message_op"]),
         )
 
 

{bec_lib-4.4.0 → bec_lib-4.4.2}/bec_lib/redis_connector/managed_redis_connection.py

@@ -510,10 +510,7 @@ class ManagedRedisConnection:
                     [(t, self._redis_conn.xrange(t, "-", end)) for t, end in topics_ids.items()],
                     None,
                 )
-            return (
-                self._redis_conn.xread(topics_ids, block=200) or [],
-                None,
-            )  # type: ignore strs are fine key and id types
+            return (self._redis_conn.xread(topics_ids, block=200) or [], None)  # type: ignore strs are fine key and id types
         except redis.exceptions.ConnectionError:
             return None, self.connection_error_str
         except redis.exceptions.NoPermissionError:
@@ -556,11 +553,14 @@ class ManagedRedisConnection:
             # Then read all the normal streams
             with self._stream_subs.lock:
                 normal_topics = self._stream_subs.topic_ids()
-                normal_subs = self._stream_subs.normal_subs
             normal_error = None
             if normal_topics:
                 response, normal_error = self._try_read_streams(normal_topics)
                 if normal_error is None:
+                    # Take the subscribers after the blocking read so that sub changes during the
+                    # read take immediate effect
+                    with self._stream_subs.lock:
+                        normal_subs = self._stream_subs.normal_subs
                     updated_ids = self._handle_stream_msg_list(response, normal_subs)
                 else:
                     updated_ids = {}

{bec_lib-4.4.0 → bec_lib-4.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_lib"
-version = "4.4.0"
+version = "4.4.2"
 description = "BEC library"
 requires-python = ">=3.11"
 classifiers = [

{bec_lib-4.4.0 → bec_lib-4.4.2}/tests/test_redis_connector_fakeredis.py

@@ -427,6 +427,36 @@ def test_redis_connector_register_stream(connected_connector):
     assert connector._stream_subs.all_topics == []
 
 
+@pytest.mark.timeout(5)
+def test_redis_connector_stream_cb_swapped_during_blocking_read(connected_connector):
+    """Callbacks (un)registered while the listener is blocked in xread must (not) receive the
+    messages that read returns."""
+    connector = connected_connector
+    cb_mock1 = mock.Mock(spec=[])
+    cb_mock2 = mock.Mock(spec=[])
+    in_read = threading.Event()
+    proceed = threading.Event()
+    orig_read = connector._try_read_streams
+
+    def blocking_read(topics_ids, from_start=False):
+        if not from_start:
+            in_read.set()
+            proceed.wait(timeout=2)
+        return orig_read(topics_ids, from_start)
+
+    with mock.patch.object(connector, "_try_read_streams", blocking_read):
+        connector.register(TestStreamEndpoint, cb=cb_mock1, start_thread=False)
+        assert in_read.wait(timeout=2)
+        connector.unregister("test", cb=cb_mock1)
+        connector.register(TestStreamEndpoint, cb=cb_mock2, start_thread=False)
+        connector.xadd("test", {"data": 1})
+        proceed.set()
+        # raises TimeoutError if the message was dropped instead of delivered to cb_mock2
+        connector.poll_messages(timeout=2)
+    cb_mock1.assert_not_called()
+    cb_mock2.assert_called_once_with({"data": 1})
+
+
 @pytest.mark.timeout(10)
 def test_redis_connector_register_stream_identical(connected_connector):
     connector = connected_connector

{bec_lib-4.4.0 → bec_lib-4.4.2}/tests/test_serializer.py

@@ -12,7 +12,7 @@ from bec_lib import messages
 from bec_lib.codecs import BECCodec
 from bec_lib.device import DeviceBase
 from bec_lib.devicemanager import DeviceManagerBase
-from bec_lib.endpoints import MessageEndpoints
+from bec_lib.endpoints import MessageEndpoints, MessageOp
 from bec_lib.serialization import MsgpackSerialization, json_ext, msgpack
 
 
@@ -214,6 +214,13 @@ def test_enum_serializer(serializer):
     assert serializer.loads(serializer.dumps(CustomEnum.VALUE1)) == "value1"
 
 
+def test_endpoint_info_decodes_to_enum(serializer):
+    endpoint = MessageEndpoints.scan_interlock_enabled()
+    restored = serializer.loads(serializer.dumps(endpoint))
+    assert restored == endpoint
+    assert restored.message_op is MessageOp.STREAM
+
+
 def test_serializer_encoding_on_failure():
     """
     Test that an exception raised during serialization is caught and the original object is returned.