benchlab-pytools 3.2.0__tar.gz → 3.2.1__tar.gz

{benchlab_pytools-3.2.0 → benchlab_pytools-3.2.1}/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to BENCHLAB PyTools are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [SemVer](https://semver.org/).
 
+## [3.2.1] - 2026-10-01
+
+### Fixed
+- Collector recovery after incomplete sensor reads
+  (`benchlab.restapi.telemetry_api.read_device_loop`): incomplete serial
+  responses (`read_sensors()` returning `None`) are now treated as read
+  failures instead of being silently ignored, so the collector reconnects
+  instead of continuing to publish stale telemetry. The read-error
+  backoff counter now survives serial port reopen attempts and resets
+  only after a successfully decoded sample, restoring the intended
+  retry/backoff policy. A device is marked `connected` only once a
+  sample has actually been decoded, and stale telemetry is cleared
+  before the collector waits to retry. (#77)
+
 ## [3.2.0] - 2026-09-29
 
 ### Added
@@ -159,6 +173,7 @@ export, MQTT publisher, VU dials, WigiDash, and config import/export tools,
 sharing a common data-source layer (direct serial, FastAPI, MQTT, named
 pipe, service HTTP, service WebSocket).
 
+[3.2.1]: https://github.com/BenchLab-io/benchlab-pytools/compare/v3.2.0...v3.2.1
 [3.2.0]: https://github.com/BenchLab-io/benchlab-pytools/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/BenchLab-io/benchlab-pytools/compare/v3.0.4...v3.1.0
 [3.0.4]: https://github.com/BenchLab-io/benchlab-pytools/compare/v3.0.3...v3.0.4

{benchlab_pytools-3.2.0 → benchlab_pytools-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: benchlab-pytools
-Version: 3.2.0
+Version: 3.2.1
 Summary: Python control suite for BENCHLAB telemetry devices
 Project-URL: Homepage, https://benchlab.io/
 Project-URL: Repository, https://github.com/BenchLab-io/benchlab-pytools

{benchlab_pytools-3.2.0 → benchlab_pytools-3.2.1}/benchlab/__init__.py

@@ -2,4 +2,4 @@
 BENCHLAB Telemetry Package
 """
 
-__version__ = "3.2.0"
+__version__ = "3.2.1"

{benchlab_pytools-3.2.0 → benchlab_pytools-3.2.1}/benchlab/restapi/telemetry_api.py

@@ -441,30 +441,25 @@ def read_device_loop(port, uid):
     reconnection logic."""
     ser = None
     consecutive_errors = 0
-    max_consecutive_errors = 10  # After this many errors, attempt reconnect
+    max_consecutive_errors = 10  # Back off after repeated read failures
     product_id = None  # Will be set once we read device info
-    is_connected = False  # Track connection status
+    is_connected = False  # Only valid telemetry establishes a connection
+    with data_lock:
+        was_connected = devices_data.get(uid, {}).get("connected", False)
+        if uid in devices_data:
+            devices_data[uid]["connected"] = False
+            devices_data[uid]["latest"] = create_empty_telemetry()
+    if was_connected:
+        schedule_device_event(uid, "disconnected")
 
     while not shutdown_event.is_set():
         # --- (Re)connect ---
         if ser is None:
-            # Mark as disconnected
-            if is_connected:
-                is_connected = False
-                with data_lock:
-                    if uid in devices_data:
-                        devices_data[uid]["connected"] = False
-                        devices_data[uid]["latest"] = create_empty_telemetry()
-                schedule_device_event(uid, "disconnected")
-                logger.info("[%s] Device disconnected", uid)
-
             try:
                 new_ser = open_serial_connection(port)
                 if new_ser is None:
                     raise OSError("open_serial_connection returned None")
                 ser = new_ser
-                # Reset error counter on successful connect
-                consecutive_errors = 0
 
                 # Read device info to get product_id for sensor reading
                 try:
@@ -481,18 +476,12 @@ def read_device_loop(port, uid):
                 except Exception:
                     pass
 
-                is_connected = True
-                with data_lock:
-                    if uid in devices_data:
-                        devices_data[uid]["connected"] = True
-                schedule_device_event(uid, "connected")
-                logger.info("Connected to device %s on %s", uid, port)
             except Exception as exc:
                 ser = None  # Ensure ser is None on error
                 consecutive_errors += 1
                 delay = min(
                     RECONNECT_DELAY * consecutive_errors,
-                    30)  # Exponential backoff, capped
+                    30)  # Linear backoff, capped
                 logger.warning(
                     "[%s] Failed to open serial port %s: %s (retry in %.1fs)",
                     uid,
@@ -509,6 +498,8 @@ def read_device_loop(port, uid):
                 shutdown_event.wait(1)
                 continue
             sensors = read_sensors(ser, product_id=product_id)
+            if sensors is None:
+                raise OSError("No complete sensor response received")
             if sensors:
                 translated = translate_sensor_struct(sensors)
                 translated["timestamp"] = datetime.now().strftime(
@@ -518,12 +509,15 @@ def read_device_loop(port, uid):
 
                 with data_lock:
                     if uid in devices_data:
+                        devices_data[uid]["connected"] = True
                         devices_data[uid]["latest"] = translated
                         devices_data[uid]["history"].append(translated)
 
+                if not is_connected:
+                    is_connected = True
+                    schedule_device_event(uid, "connected")
+                    logger.info("Connected to device %s on %s", uid, port)
                 schedule_update(uid, translated)
-            else:
-                logger.debug("[%s] No sensor data read", uid)
         except Exception as e:
             consecutive_errors += 1
             # Specific debug logging for unsupported commands
@@ -547,8 +541,18 @@ def read_device_loop(port, uid):
             except Exception:
                 pass
             ser = None
+            was_connected = is_connected
+            if is_connected:
+                logger.info("[%s] Device disconnected", uid)
+            is_connected = False
+            with data_lock:
+                if uid in devices_data:
+                    devices_data[uid]["connected"] = False
+                    devices_data[uid]["latest"] = create_empty_telemetry()
+            if was_connected:
+                schedule_device_event(uid, "disconnected")
 
-            # Exponential backoff with cap
+            # Linear backoff with cap
             if consecutive_errors >= max_consecutive_errors:
                 delay = min(RECONNECT_DELAY * consecutive_errors, 30)
                 logger.warning(

benchlab_pytools-3.2.1/benchlab/restapi/test_read_recovery.py

@@ -0,0 +1,235 @@
+"""Fault injection for the collector's serial recovery; no hardware needed."""
+from collections import deque
+from unittest.mock import MagicMock, call
+
+import pytest
+
+from benchlab.restapi import telemetry_api as api
+
+
+class StopEvent:
+    def __init__(self):
+        self.stopped = False
+        self.waits = []
+        self.on_wait = lambda _: None
+
+    def is_set(self):
+        return self.stopped
+
+    def wait(self, delay):
+        self.waits.append(delay)
+        self.on_wait(delay)
+        return self.stopped
+
+
+@pytest.fixture
+def reader(monkeypatch):
+    stop = StopEvent()
+    device = {"connected": False, "latest": {}, "history": deque()}
+    connections = []
+
+    def open_port(_):
+        ser = MagicMock()
+        connections.append(ser)
+        if len(connections) > 30:
+            stop.stopped = True  # Bound regressions that never reach backoff.
+        return ser
+
+    monkeypatch.setattr(api, "shutdown_event", stop)
+    monkeypatch.setattr(api, "devices_data", {"test": device})
+    monkeypatch.setattr(api, "open_serial_connection", open_port)
+    monkeypatch.setattr(api, "read_device", lambda _: {"ProductId": 16})
+    monkeypatch.setattr(
+        api, "translate_sensor_struct", lambda _: {"TS_2": 24.0})
+    trace = []
+    snapshots = []
+
+    def device_event(uid, event):
+        # Record rather than assert here: the reader catches exceptions.
+        unlocked = api.data_lock.acquire(blocking=False)
+        if unlocked:
+            api.data_lock.release()
+        wire = api._device_to_wire_shape(uid) if unlocked else {}
+        snapshots.append((event, device["connected"],
+                          device["latest"].copy(), unlocked, wire))
+        trace.append(event)
+
+    events = MagicMock(side_effect=device_event)
+    publish = MagicMock(side_effect=lambda *_: trace.append("telemetry"))
+    monkeypatch.setattr(api, "schedule_update", publish)
+    monkeypatch.setattr(api, "schedule_device_event", events)
+    yield stop, device, connections, publish, events, trace
+
+    for event, connected, latest, unlocked, wire in snapshots:
+        assert unlocked, "Device event scheduled while holding data_lock"
+        assert connected == (event == "connected")
+        assert wire["status"] == event.upper()
+        if connected:
+            assert latest["TS_2"] == 24.0
+        else:
+            assert latest["connected"] is False
+            assert latest["TS_2"] == 0
+
+
+@pytest.mark.parametrize("failure", [None, OSError("USB disconnected")])
+def test_failed_read_discards_stale_data_and_reconnects(
+        monkeypatch, reader, failure):
+    stop, device, connections, publish, events, trace = reader
+    reads = 0
+
+    def read(*args, **kwargs):
+        nonlocal reads
+        reads += 1
+        if reads >= 3:
+            stop.stopped = True
+        if reads == 2:
+            assert device["connected"]
+            if isinstance(failure, Exception):
+                raise failure
+            return failure
+        if reads == 3:
+            assert not device["connected"]
+            assert device["latest"]["connected"] is False
+            assert len(connections) == 2
+            stop.stopped = True
+        return object()
+
+    monkeypatch.setattr(api, "read_sensors", read)
+    api.read_device_loop("/fake", "test")
+    assert publish.call_count == 2
+    assert trace == ["connected", "telemetry", "disconnected",
+                     "connected", "telemetry", "disconnected"]
+    assert events.call_args_list == [
+        call("test", "connected"), call("test", "disconnected"),
+        call("test", "connected"), call("test", "disconnected"),
+    ]
+    assert len(device["history"]) == 2
+    assert all(s.close.call_count == 1 for s in connections)
+
+
+@pytest.mark.parametrize("failure", [None, OSError("read failed")])
+def test_repeated_read_failures_back_off_even_when_open_succeeds(
+        monkeypatch, reader, failure):
+    stop, device, connections, publish, events, trace = reader
+
+    def read(*args, **kwargs):
+        assert not device["connected"]
+        if isinstance(failure, Exception):
+            raise failure
+        return failure
+
+    def waited(delay):
+        assert not device["connected"]
+        assert device["latest"]["connected"] is False
+        stop.stopped = True
+
+    stop.on_wait = waited
+    monkeypatch.setattr(api, "read_sensors", read)
+    api.read_device_loop("/fake", "test")
+    assert len(connections) == 10
+    assert stop.waits == [min(api.RECONNECT_DELAY * 10, 30)]
+    publish.assert_not_called()
+    assert not device["history"]
+    events.assert_not_called()
+    assert all(s.close.call_count == 1 for s in connections)
+
+
+def test_valid_sample_resets_failure_streak(monkeypatch, reader):
+    stop, device, connections, publish, events, trace = reader
+    reads = 0
+
+    def read(*args, **kwargs):
+        nonlocal reads
+        reads += 1
+        if reads > 30:
+            stop.stopped = True
+        if reads == 10:
+            return object()
+        return None
+
+    def waited(delay):
+        if delay == api.poll_interval:
+            assert device["connected"]
+        else:
+            assert reads == 20
+            stop.stopped = True
+
+    stop.on_wait = waited
+    monkeypatch.setattr(api, "read_sensors", read)
+    api.read_device_loop("/fake", "test")
+    assert stop.waits == [api.poll_interval, min(api.RECONNECT_DELAY * 10, 30)]
+    publish.assert_called_once()
+    assert len(device["history"]) == 1
+    assert trace == ["connected", "telemetry", "disconnected"]
+
+
+@pytest.mark.parametrize("initially_connected", [False, True])
+def test_failed_initial_open_clears_discovery_connected_flag(
+        monkeypatch, reader, initially_connected):
+    stop, device, connections, publish, events, trace = reader
+    device.update(connected=initially_connected, latest={"TS_2": 24.0})
+    monkeypatch.setattr(api, "open_serial_connection", lambda _: None)
+
+    def waited(delay):
+        assert not device["connected"]
+        assert device["latest"]["connected"] is False
+        stop.stopped = True
+
+    stop.on_wait = waited
+    api.read_device_loop("/fake", "test")
+    assert stop.waits == [min(api.RECONNECT_DELAY, 30)]
+    publish.assert_not_called()
+    assert trace == (["disconnected"] if initially_connected else [])
+
+
+def test_steady_samples_emit_one_connection_and_shutdown_event(
+        monkeypatch, reader):
+    stop, device, connections, publish, events, trace = reader
+    reads = 0
+
+    def read(*args, **kwargs):
+        nonlocal reads
+        reads += 1
+        if reads >= 3:
+            stop.stopped = True
+        return object()
+
+    monkeypatch.setattr(api, "read_sensors", read)
+    api.read_device_loop("/fake", "test")
+    assert trace == ["connected", "telemetry", "telemetry", "telemetry",
+                     "disconnected"]
+    assert len(connections) == 1
+    assert publish.call_count == 3
+    assert not device["connected"]
+    assert connections[0].close.call_count == 1
+
+
+@pytest.mark.parametrize("failure", [None, OSError("read failed")])
+def test_disconnect_event_precedes_backoff(monkeypatch, reader, failure):
+    stop, device, connections, publish, events, trace = reader
+    reads = 0
+    backoff_traces = []
+
+    def read(*args, **kwargs):
+        nonlocal reads
+        reads += 1
+        if reads > 15:
+            stop.stopped = True
+        if reads == 1:
+            return object()
+        if isinstance(failure, Exception):
+            raise failure
+        return failure
+
+    def waited(delay):
+        if delay != api.poll_interval:
+            backoff_traces.append(trace.copy())
+            stop.stopped = True
+
+    stop.on_wait = waited
+    monkeypatch.setattr(api, "read_sensors", read)
+    api.read_device_loop("/fake", "test")
+    assert reads == 11
+    assert backoff_traces == [["connected", "telemetry", "disconnected"]]
+    assert trace == backoff_traces[0]
+    assert stop.waits == [api.poll_interval, min(api.RECONNECT_DELAY * 10, 30)]