bec-server 4.0.1__tar.gz → 4.0.2__tar.gz

{bec_server-4.0.1 → bec_server-4.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec-server
-Version: 4.0.1
+Version: 4.0.2
 Summary: BEC server
 Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
 Project-URL: Homepage, https://github.com/bec-project/bec

{bec_server-4.0.1 → bec_server-4.0.2}/bec_server/file_writer/async_writer.py

@@ -303,7 +303,12 @@ class AsyncWriter(threading.Thread):
                         if key == "value":
                             self.write_value_data(signal_group, value, async_update)
                         elif key == "timestamp":
-                            self.write_timestamp_data(signal_group, value)
+                            self.write_timestamp_data(
+                                signal_group,
+                                value,
+                                replace=isinstance(async_update, dict)
+                                and async_update.get("type") == "replace",
+                            )
                         else:  # pragma: no cover
                             # this should never happen as the keys are fixed in the pydantic model
                             msg = f"Unknown key: {key}. Data will not be written."
@@ -354,7 +359,7 @@ class AsyncWriter(threading.Thread):
 
         elif update_type == "replace":
             # store the data to be written after the scan is complete
-            self.device_data_replace[signal_group.name] = value
+            self.device_data_replace[signal_group.name] = np.asarray(value)
         else:
             msg = f"Unknown async update type: {update_type}. Data will not be written."
             self.connector.raise_alarm(
@@ -578,19 +583,26 @@ class AsyncWriter(threading.Thread):
                 )
         self.cursor[signal_group.name][row_index] = value.shape[1]
 
-    def write_timestamp_data(self, signal_group, value):
+    def write_timestamp_data(
+        self, signal_group: h5py.Group, value: Any, replace: bool = False
+    ) -> None:
         """
         Write the timestamp data to the file.
         Timestamp data is always written as a 1D array, irrespective of the async update type.
+        Replacement updates retain only the latest timestamps.
 
         Args:
             signal_group (h5py.Group): The group to write the data to
-            value (list): The timestamp data to write
+            value (Any): The timestamp data to write
+            replace (bool): Whether to replace existing timestamps instead of appending
         """
         if not isinstance(value, (list, np.ndarray)):
             value = [value]
         if "timestamp" not in signal_group:
             create_dataset_safe(signal_group, "timestamp", data=value, maxshape=(None,))
+        elif replace:
+            signal_group["timestamp"].resize((len(value),))
+            signal_group["timestamp"][:] = value
         else:
             signal_group["timestamp"].resize((len(signal_group["timestamp"]) + len(value),))
             signal_group["timestamp"][-len(value) :] = value

{bec_server-4.0.1 → bec_server-4.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec-server"
-version = "4.0.1"
+version = "4.0.2"
 description = "BEC server"
 requires-python = ">=3.11"
 classifiers = [

{bec_server-4.0.1 → bec_server-4.0.2}/tests/tests_file_writer/test_async_file_writer.py

@@ -591,9 +591,65 @@ def test_async_writer_replace(async_writer, data):
     # read the data back
     with h5py.File(async_writer.file_path, "r") as f:
         out = f[async_writer.BASE_PATH]["monitor_async"]["monitor_async"]["value"][:]
+        timestamps = f[async_writer.BASE_PATH]["monitor_async"]["monitor_async"]["timestamp"][:]
 
     assert out.shape == (10,)
     assert np.allclose(out, data[-1].signals["monitor_async"]["value"])
+    assert np.array_equal(timestamps, [data[-1].signals["monitor_async"]["timestamp"]])
+
+
+@pytest.mark.parametrize(
+    "values",
+    [
+        (0, 7),
+        (0.0, 1.2),
+        (False, True),
+        (np.int64(0), np.int64(7)),
+        (np.float64(0.0), np.float64(1.2)),
+    ],
+)
+def test_async_writer_replace_scalar(async_writer, values):
+    """Write only the latest scalar value and timestamp after scan completion."""
+    for timestamp, value in enumerate(values, start=1):
+        message = messages.DeviceMessage(
+            signals={"monitor_async": {"value": value, "timestamp": float(timestamp)}},
+            metadata={"async_update": {"type": "replace"}},
+        )
+        async_writer.write_data({"monitor_async": [message]})
+
+    group = async_writer.file_handle[f"{async_writer.BASE_PATH}/monitor_async/monitor_async"]
+    try:
+        assert "value" not in group
+        async_writer.write_data({}, write_replace=True)
+        assert group["value"].shape == ()
+        assert group["value"][()] == values[-1]
+        assert np.array_equal(group["timestamp"][:], [2.0])
+    finally:
+        async_writer.file_handle.close()
+
+
+@pytest.mark.parametrize("update_type", ["replace", "add", "add_slice"])
+@pytest.mark.parametrize("timestamps", [[1, 2, 3], [1]])
+def test_async_writer_timestamp_aggregation(async_writer, update_type, timestamps):
+    """Keep replacement timestamps together and preserve append behavior for other updates."""
+    metadata = {"type": update_type}
+    if update_type == "add":
+        metadata["max_shape"] = [None]
+    elif update_type == "add_slice":
+        metadata.update(max_shape=[None, None], index=0)
+
+    for timestamp in (timestamps, [4, 5]):
+        message = messages.DeviceMessage(
+            signals={"monitor_async": {"value": np.array([6, 7]), "timestamp": timestamp}},
+            metadata={"async_update": metadata},
+        )
+        async_writer.write_data({"monitor_async": [message]})
+    async_writer.write_data({}, write_replace=True)
+
+    group = async_writer.file_handle[f"{async_writer.BASE_PATH}/monitor_async/monitor_async"]
+    expected = [4, 5] if update_type == "replace" else timestamps + [4, 5]
+    assert np.array_equal(group["timestamp"][:], expected)
+    async_writer.file_handle.close()
 
 
 def test_async_writer_async_signal(async_writer):