rosotacom-dev 2.5.dev57__tar.gz → 2.5.dev58__tar.gz

{rosotacom_dev-2.5.dev57 → rosotacom_dev-2.5.dev58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev57
+Version: 2.5.dev58
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev57 → rosotacom_dev-2.5.dev58}/src/rosotacom/resources/ws/ros2src/com_py/com_py/playout_pacer_core.py

@@ -32,7 +32,10 @@ class PacerConfig:
     adaptive: bool = True
     percentile: float = 0.95  # of (arrival - stamp), window-local
     margin_ms: float = 40.0  # headroom above the tracked percentile
-    window: int = 400  # samples (~40 s at 10 Hz)
+    #: Samples (~40 s at 10 Hz). Bounds both the tracked percentile and the
+    #: delay floor, so how fast the schedule re-anchors after the path changes
+    #: is this number: a longer window is steadier and slower to recover.
+    window: int = 400
 
     def __post_init__(self) -> None:
         if not 0.0 < self.percentile < 1.0:
@@ -72,8 +75,18 @@ class PlayoutSchedule:
         """
         d = arrival_s - stamp_s
         self._d.append(d)
-        if self._d_floor is None or d < self._d_floor:
-            self._d_floor = d
+        # The minimum over the *window*, not over all time. An all-time floor
+        # can only fall, so any upward shift in `arrival - stamp` -- a clock
+        # step, an NTP correction, a route change, a looping replay -- leaves
+        # every later message past `stamp + floor + budget`, and the pacer
+        # degrades to a pass-through it can never come back from. Found on the
+        # fleet e2e, where a bag loop moved the delay by the bag's length and
+        # the centre's camera ran unpaced for the rest of the run with every
+        # panel healthy. Windowed, the same shift re-anchors within one window.
+        #
+        # O(window) per message: 400 floats at 10 Hz. A monotonic deque would
+        # make it O(1) and is not worth the machinery at these rates.
+        self._d_floor = min(self._d)
         release = stamp_s + self._d_floor + self.budget_ms / 1000.0
         if release < arrival_s:  # already late: pass through immediately
             release = arrival_s

{rosotacom_dev-2.5.dev57 → rosotacom_dev-2.5.dev58}/src/rosotacom_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev57
+Version: 2.5.dev58
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev57 → rosotacom_dev-2.5.dev58}/src/rosotacom_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "2.4",
-  "distance": 57,
-  "node": "gd5c85e0fb2b514ef6c7827c2706cb96b8467fdea",
+  "distance": 58,
+  "node": "ge746c2a24a5de807925ed1cc3b61921a542c2ac2",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{rosotacom_dev-2.5.dev57 → rosotacom_dev-2.5.dev58}/tests/unit/test_playout_pacer.py

@@ -111,3 +111,57 @@ def test_a_late_message_is_reported_as_held_for_nothing() -> None:
     _hold_ms(schedule, 0.0, 0.030)
 
     assert _hold_ms(schedule, 1.0, 1.400) == 0.0
+
+
+# The floor has to be able to rise again (#312).
+#
+# Every budget is anchored to `d_floor`, the fastest path observed. Taking that
+# over all time rather than over the window means it can only fall, so one
+# upward shift in `arrival - stamp` puts every later message past its release
+# time and the pacer becomes a pass-through it never recovers from. A clock step
+# on either peer is enough; the fleet e2e's looping bag replay does it every
+# lap, and until #301 the symptom was invisible -- node up, topic flowing,
+# nothing re-timed.
+
+
+def _hold_p50(schedule: PlayoutSchedule, count: int, stamp0: float, offset: float) -> float:
+    holds = []
+    for index in range(count):
+        stamp = stamp0 + index * 0.1
+        # 10 ms most of the time, 50 ms every third message: enough jitter for
+        # an adaptive budget to have something to track.
+        arrival = stamp + offset + (0.05 if index % 3 == 0 else 0.01)
+        holds.append(max(0.0, (schedule.on_message(stamp, arrival) - arrival) * 1000.0))
+    return sorted(holds)[len(holds) // 2]
+
+
+def test_a_delay_step_up_is_re_anchored_within_one_window() -> None:
+    schedule = PlayoutSchedule(PacerConfig(adaptive=True, min_ms=100.0, max_ms=300.0))
+    window = schedule.config.window
+
+    assert _hold_p50(schedule, 500, 0.0, 0.20) == pytest.approx(100.0, abs=5.0)
+    # The step itself is absorbed, not smoothed: those messages are genuinely
+    # late relative to what was known, and pass through.
+    _hold_p50(schedule, window, 1000.0, 161.20)
+    # One window later the floor describes the new path again.
+    assert _hold_p50(schedule, 500, 2000.0, 161.20) == pytest.approx(100.0, abs=5.0)
+
+
+def test_a_constant_offset_is_still_absorbed_entirely() -> None:
+    """The property the floor exists for: no clock synchronization needed."""
+    near = PlayoutSchedule(PacerConfig(adaptive=True, min_ms=100.0, max_ms=300.0))
+    far = PlayoutSchedule(PacerConfig(adaptive=True, min_ms=100.0, max_ms=300.0))
+
+    assert _hold_p50(near, 500, 0.0, 0.20) == pytest.approx(_hold_p50(far, 500, 0.0, 3600.20), abs=1.0)
+
+
+def test_the_step_neither_drops_nor_reorders() -> None:
+    schedule = PlayoutSchedule(PacerConfig(adaptive=True, min_ms=100.0, max_ms=300.0))
+    releases = []
+    for index in range(600):
+        stamp = index * 0.1
+        offset = 0.20 if index < 300 else 161.20
+        releases.append(schedule.on_message(stamp, stamp + offset + 0.01))
+
+    assert len(releases) == 600
+    assert releases == sorted(releases)