test(starlark): stop the pixlet-editor route tests leaking a fake Popen into the captive-portal check

TestPixletEditorHostDefaultsButDoesNotOverride patched Popen on the shared
subprocess module. The app's before_request captive-portal hook runs
subprocess.run (`with Popen(...) as p`) for `systemctl is-active hostapd`
whenever its 30s AP-mode cache is cold, so on a Linux host with systemctl -
the CI runner - the hook got the FakeProcess and the request 500'd with
"'FakeProcess' object does not support the context manager protocol".
Whether it happened depended on how long ago the previous request ran,
hence the intermittency; Windows has no systemctl and never reached it.

- Patch the starlark route module's own `subprocess` binding instead of
  the global Popen.
- Pin is_ap_mode_active to False in this file's client fixture, so no
  request here shells out to systemctl/nmcli at all.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CHANGELOG.md

@@ -19,24 +19,17 @@ accepts both, but the store flags the old spelling as deprecated
 
 ## Unreleased
 
-### Scroll speed: a panel slower than its refresh cap is reported
+### A scrolling screen held by its plugin's update() is reported
 
-- Scroll speeds are solved against `limit_refresh_rate_hz`, so a panel that
-  cannot reach its cap ran every scroll slow by the shortfall, with no sign
-  why (one Pi 4 on a 120 Hz cap refreshed at ~110 Hz: 60 px/s ran at 55).
-  Once the display has measured the real rate over three windows of
-  scrolling, a panel more than 3% short of the cap is logged once, as a
-  warning from `src.common.frame_timing` that names a cap it can hold (a
-  multiple of 10, 5% under the measurement). The Display tab shows the same
-  under Limit Refresh Rate, with a button that fills it in, from the new
-  `GET /api/v3/config/refresh-rate`. Not checked in the emulator or on the
-  fallback canvas.
-- The frame-stats file records `planned_refresh_hz` (additive), and the
-  scroll-speed advice behind the Vegas slider ignores a measurement written
-  under a different cap. Until now, after the cap changed, the slider kept
-  advising from the old rate until the display restarted.
-- New in `src.common.scroll_config`: `refresh_shortfall()`, `holdable_cap()`
-  and `describe_refresh_shortfall()`.
+- While a plugin's `update()` runs it holds the plugin's lock, and that
+  plugin's frames are skipped: on a scroller, a frozen strip, with nothing
+  logged (and a freeze of 5 s or more is a gap, not a freeze, to the frame
+  stats). The high-FPS loop now times each run of skipped frames; one of
+  250 ms or more logs `Display of <plugin> held N ms by its update()`
+  (rate-limited per plugin) when it ends, and is recorded on the plugin's
+  health as a `display hold` busy skip, which never counts toward the
+  circuit breaker. The 1 Hz loop is left out: its frames are a second apart,
+  so one skipped frame there measures nothing and freezes nothing visible.
 
 ### Fixed
 

docs/SCROLL_PERFORMANCE.md

@@ -77,31 +77,6 @@ The Vegas **Scroll Speed** slider in the web UI shows the same thing live: a
 line under it says what your speed will run as on this panel, and links to the
 nearest smooth speeds.
 
-### A panel that cannot reach its cap
-
-Speeds are solved against `limit_refresh_rate_hz`, the configured cap, but a
-cap is only a ceiling: a long chain, a high `pwm_bits` or a big
-`gpio_slowdown` can leave the panel below it. One Pi 4 driving 2×128×64 on
-`adafruit-hat-pwm` with `pwm_bits 9` and `gpio_slowdown 5` measured
-107.6–113.1 Hz under a 120 Hz cap. Frames still move whole pixels, but
-every scroll runs that much slower than configured (60 px/s ran at 55 px/s),
-and the smooth speeds are the cap's rather than the panel's.
-
-The display measures the real rate from its own frames. About a minute
-into scrolling, a panel more than 3% short of its cap is logged once:
-
-```
-WARNING - src.common.frame_timing - The panel refreshes at about 113 Hz, below
-the 120 Hz that scroll speeds are planned for ... Set Limit Refresh Rate to
-100 Hz (web UI, Display tab), which this panel can hold, and restart.
-```
-
-The Display tab says the same under **Limit Refresh Rate**, with a button
-that fills in the suggested cap (`GET /api/v3/config/refresh-rate`). The
-suggestion is a multiple of 10 at least 5% under the measurement, because
-an uncapped panel drifts and the measurement is the fast end of it. A cap the
-panel holds also stops the drift.
-
 ### How a slow speed stays crisp
 
 `SwapOnVSync(canvas, framerate_fraction)` holds each frame for N panel

src/common/frame_timing.py

@@ -135,8 +135,6 @@ import time
 import traceback
 from typing import Any, Callable, Dict, List, Optional, Tuple, TypedDict
 
-from src.common import scroll_config
-
 logger = logging.getLogger(__name__)
 
 #: Bumped when a field changes meaning, so a reader can refuse stale files.
@@ -181,12 +179,6 @@ MAX_REFRESH_DROP = 0.2
 #: trusted -- about a second of scrolling.
 MIN_FRAMES_FOR_REFRESH = 90
 
-#: Trusted windows, counting the one that adopted the period, before a panel
-#: slower than its cap is reported. The estimate can still fall (the refresh
-#: rate rise) by up to MAX_REFRESH_DROP per window early on; the warning
-#: should not name a rate one more window would have corrected.
-REFRESH_CHECK_WINDOWS = 3
-
 FLUSH_INTERVAL = 10.0
 
 #: A scroll's last frame older than this is a stall worth a stack dump.
@@ -449,12 +441,6 @@ class FrameTimingRecorder:
             1.0 / refresh_hz if refresh_hz and refresh_hz > 0 else None)
         # The first estimate, until a second window agrees with it.
         self._refresh_candidate: Optional[float] = None
-        # The rate scroll speeds are solved against; see plan_refresh().
-        self.planned_refresh_hz: Optional[float] = None
-        # Trusted windows seen since the period was adopted, until the
-        # shortfall check has run.
-        self._refresh_windows = 0
-        self._shortfall_checked = True
         self.totals: Dict[str, Any] = {
             "static_frames": 0,
             "scroll_frames": 0,
@@ -653,12 +639,7 @@ class FrameTimingRecorder:
                     self._refresh_candidate = estimate
             elif current * (1.0 - MAX_REFRESH_DROP) <= estimate < current:
                 self.refresh_period = estimate
-            if self.refresh_period is not None:
-                self._refresh_windows += 1
         period = self.refresh_period
-        if (period and not self._shortfall_checked
-                and self._refresh_windows >= REFRESH_CHECK_WINDOWS):
-            self._check_refresh_shortfall(1.0 / period)
 
         histograms = self.histograms
         for frame in batch:
@@ -707,25 +688,6 @@ class FrameTimingRecorder:
                 elif missed <= -1:
                     totals["early_frames"] += 1
 
-    def plan_refresh(self, hz: Optional[float]) -> None:
-        """Say what rate scroll speeds are solved against, before frames arrive.
-
-        ``DisplayManager.refresh_hz``: the configured cap. Once the measured
-        rate has held for :data:`REFRESH_CHECK_WINDOWS` windows, a panel that
-        falls short of it is logged once, with a cap it can hold (see
-        :func:`src.common.scroll_config.refresh_shortfall`). The display
-        manager calls this only for a real panel.
-        """
-        self.planned_refresh_hz = hz
-        self._shortfall_checked = not hz
-
-    def _check_refresh_shortfall(self, measured_hz: float) -> None:
-        """Log, once, a panel that cannot reach the rate speeds assume."""
-        self._shortfall_checked = True
-        shortfall = scroll_config.refresh_shortfall(measured_hz, self.planned_refresh_hz)
-        if shortfall:
-            logger.warning(scroll_config.describe_refresh_shortfall(shortfall))
-
     def snapshot(self) -> Dict[str, Any]:
         """The JSON document: cumulative since this process started."""
         if not self._binding_checked:
@@ -742,9 +704,6 @@ class FrameTimingRecorder:
             "bucket_ms": BUCKET_MS,
             "freeze_seconds": FREEZE_SECONDS,
             "measured_refresh_hz": round(1.0 / period, 2) if period else None,
-            # Additive: what scroll speeds were solved against, so a reader can
-            # tell a stale file (written under another cap) from this one.
-            "planned_refresh_hz": self.planned_refresh_hz,
             "binding_releases_gil": self._binding_gil,
             "info": info,
             "totals": copy.deepcopy(self.totals),

src/common/scroll_config.py

@@ -538,66 +538,3 @@ def speed_advice(
         "smooth": smooth,
         "alternatives": [as_dict(c) for c in alternatives],
     }
-
-
-#: A measured refresh this far below the rate speeds are planned for means
-#: the panel cannot reach its cap. Smaller gaps are the cap's own slack and
-#: the estimate's: one rig measured 99.95 Hz under a 100 Hz cap.
-REFRESH_SHORTFALL = 0.03
-
-#: How far under the measured rate a suggested cap sits. The measurement is
-#: the fast end of the panel's refreshes (frame_timing takes the 10th
-#: percentile of intervals), and an uncapped panel drifts: one read
-#: 107.6-113.1 Hz over 15 seconds. A cap inside that band would not hold.
-CAP_HEADROOM = 0.05
-
-
-def holdable_cap(measured_hz: Any) -> Optional[int]:
-    """A refresh cap the panel can hold: a multiple of 10, 5% under what it measured.
-
-    A multiple of 10 because its whole-pixel speeds are round numbers (a
-    100 Hz cap gives 50 and 100 px/s). None without a usable measurement, or
-    when the panel is too slow for any cap of 10 Hz or more.
-    """
-    hz = _coerce(measured_hz)
-    if hz is None:
-        return None
-    cap = int(hz * (1.0 - CAP_HEADROOM) // 10) * 10
-    return cap if cap >= 10 else None
-
-
-def refresh_shortfall(measured_hz: Any, planned_hz: Any) -> Optional[Dict[str, Any]]:
-    """When the panel refreshes measurably slower than speeds are planned for.
-
-    ``planned_hz`` is what :func:`configure` solves against -- the
-    ``limit_refresh_rate_hz`` cap, or :data:`DEFAULT_REFRESH_HZ` when it is 0.
-    A panel that cannot reach it still moves whole pixels per frame, but every
-    speed runs slow by the shortfall and the ladder of smooth speeds is the
-    cap's, not the panel's. None when there is no measurement, or the panel
-    reaches the cap (or beats it, as some do by a few Hz).
-    """
-    measured, planned = _coerce(measured_hz), _coerce(planned_hz)
-    if measured is None or planned is None:
-        return None
-    if measured >= planned * (1.0 - REFRESH_SHORTFALL):
-        return None
-    return {
-        "measured_hz": round(measured, 1),
-        "planned_hz": round(planned, 1),
-        "suggested_cap_hz": holdable_cap(measured),
-        "slow_percent": round((1.0 - measured / planned) * 100),
-    }
-
-
-def describe_refresh_shortfall(shortfall: Dict[str, Any]) -> str:
-    """One log line for :func:`refresh_shortfall`'s answer."""
-    text = (
-        f"The panel refreshes at about {shortfall['measured_hz']:.0f} Hz, below "
-        f"the {shortfall['planned_hz']:.0f} Hz that scroll speeds are planned "
-        f"for (display.hardware.limit_refresh_rate_hz), so every scroll runs "
-        f"about {shortfall['slow_percent']}% slower than configured and the "
-        f"smooth speeds are worked out for a rate this panel never reaches.")
-    if shortfall.get("suggested_cap_hz"):
-        text += (f" Set Limit Refresh Rate to {shortfall['suggested_cap_hz']} Hz "
-                 f"(web UI, Display tab), which this panel can hold, and restart.")
-    return text

src/display_controller.py

@@ -1164,6 +1164,55 @@ class DisplayController:
         except Exception:  # pylint: disable=broad-except
             logger.exception("Error running scheduled plugin updates")
 
+    #: A run of frames skipped because a plugin's update() held its lock is
+    #: reported once it has lasted this long.
+    DISPLAY_HOLD_REPORT_SECONDS = 0.25
+
+    #: (plugin_id, monotonic start) of the current run of skipped frames.
+    _display_hold: Optional[Tuple[str, float]] = None
+
+    def _note_display_hold(self, plugin_id: str, held: bool) -> None:
+        """Report how long a plugin's update() kept its display() from drawing.
+
+        While update() runs on the worker it holds the plugin's lock, and every
+        frame of that plugin's screen is skipped: the panel keeps showing the
+        last frame, which on a scroller is a frozen strip. Nothing said so --
+        the frames are not failures, and a scroll freeze of 5 s or more is a
+        gap to the frame stats, not a freeze. This times each such run and,
+        when it ends after DISPLAY_HOLD_REPORT_SECONDS or more, logs it
+        (rate-limited per plugin) and records it on the plugin's health as a
+        busy skip, which never touches the circuit breaker. Only frames of the
+        high-FPS loop are timed (see _display_once's ``report_hold``).
+        """
+        # The clock is read only when a run starts or ends: on a frame that
+        # draws with no run open, this is one attribute check.
+        current = self._display_hold
+        if held:
+            if current is None or current[0] != plugin_id:
+                self._display_hold = (plugin_id, time.monotonic())
+            return
+        if current is None:
+            return
+        self._display_hold = None
+        if current[0] != plugin_id:
+            return
+        seconds = time.monotonic() - current[1]
+        if seconds < self.DISPLAY_HOLD_REPORT_SECONDS:
+            return
+        pm = self.plugin_manager
+        warn = getattr(pm, '_warn_rate_limited', None)
+        if warn is not None:
+            warn(f"display-hold:{plugin_id}",
+                 "Display of %s held %.0f ms by its update()",
+                 plugin_id, seconds * 1000.0)
+        tracker = getattr(pm, 'health_tracker', None)
+        record = getattr(tracker, 'record_busy_skip', None)
+        if record is not None:
+            try:
+                record(plugin_id, "display hold", seconds)
+            except Exception:  # pylint: disable=broad-except
+                logger.debug("Could not record a display hold", exc_info=True)
+
     @contextmanager
     def _display_lock_or_skip(self, plugin_id):
         """Try-lock guard keeping a plugin's display() off its in-flight update().
@@ -1189,7 +1238,7 @@ class DisplayController:
             lock.release()
 
     def _display_once(self, plugin, mode: str, accepts_display_mode: bool,
-                      force_clear: bool = False):
+                      force_clear: bool = False, report_hold: bool = False):
         """Call ``plugin.display()`` directly for one frame of a render loop.
 
         Frames after a screen's first dispatch come through here rather than
@@ -1205,6 +1254,12 @@ class DisplayController:
                 ``display_mode`` so plugins with several modes stay on it.
             accepts_display_mode: Whether display() takes ``display_mode``.
             force_clear: Passed through to display().
+            report_hold: Time runs of frames skipped because update() holds
+                the plugin's lock (see _note_display_hold). Only the high-FPS
+                loop asks: its frames are ~8 ms apart, so a run measures the
+                hold, and a held scroller is a frozen strip. The 1 Hz loop's
+                frames are a second apart, so one skipped frame there would
+                read as a 1 s hold of a screen that did not visibly change.
 
         Each call is timed (two monotonic reads) and handed to
         PluginManager.note_display_duration, which logs and records slow
@@ -1219,6 +1274,12 @@ class DisplayController:
         display_watchdog.watchdog.beat()
         plugin_id = getattr(plugin, 'plugin_id', None)
         with self._display_lock_or_skip(plugin_id) as can_display:
+            if report_hold and plugin_id:
+                self._note_display_hold(plugin_id, held=not can_display)
+            elif can_display and self._display_hold is not None:
+                # A drawn frame outside the high-FPS loop: whatever run was
+                # open is over, unreported.
+                self._display_hold = None
             if not can_display:
                 return True
             started = time.monotonic()
@@ -3987,7 +4048,8 @@ class DisplayController:
                             _frame_start = time.perf_counter()
                             try:
                                 result = self._display_once(
-                                    manager_to_display, active_mode, _accepts_display_mode)
+                                    manager_to_display, active_mode, _accepts_display_mode,
+                                    report_hold=True)
                                 if isinstance(result, bool) and not result:
                                     logger.debug("Display returned False, breaking early")
                                     break

src/display_manager.py

@@ -393,11 +393,6 @@ class DisplayManager:
         
         self._setup_matrix()
         logger.info("Matrix setup completed in %.3f seconds", time.time() - start_time)
-        # Only a real panel's swaps wait on its refresh: the emulator and the
-        # fallback canvas pace themselves, so "slower than the cap" would be
-        # noise there.
-        if self.matrix is not None and os.environ.get('EMULATOR', 'false') != 'true':
-            self.frame_timing.plan_refresh(self.refresh_hz)
         self._setup_scan_order_compensation()
         
         font_time = time.time()
@@ -1506,9 +1501,7 @@ class DisplayManager:
         fractional-pixel motion. See src/common/scroll_config.py.
 
         Note this is the configured *cap*, not necessarily what the panel
-        achieves -- scripts/scroll_speeds.py --measure reports the real rate,
-        and the frame-timing recorder logs a warning, with a cap the panel can
-        hold, once it has measured a panel that falls short of this.
+        achieves -- scripts/scroll_speeds.py --measure reports the real rate.
         """
         hardware = (self.config.get('display') or {}).get('hardware') or {}
         try:

test/fixtures/api_v3_url_map.json

@@ -175,15 +175,6 @@
       "POST"
     ]
   ],
-  [
-    "/api/v3/config/refresh-rate",
-    "api_v3.get_refresh_rate",
-    [
-      "GET",
-      "HEAD",
-      "OPTIONS"
-    ]
-  ],
   [
     "/api/v3/config/schedule",
     "api_v3.get_schedule_config",

test/test_display_hold_report.py

@@ -0,0 +1,142 @@
+"""The report of a scrolling screen held by its plugin's update().
+
+While a plugin's update() runs it holds the plugin's lock, and its screen's
+frames are skipped -- on a scroller, a frozen strip -- with nothing logged.
+_note_display_hold times each such run and reports one of
+DISPLAY_HOLD_REPORT_SECONDS or more.
+"""
+
+import threading
+import types
+from unittest.mock import MagicMock
+
+import pytest
+
+
+class _Clock:
+    """display_controller's clock: moves only when run() sleeps or a test says."""
+
+    def __init__(self, start=10_000.0):
+        self.t = start
+
+    def now(self):
+        return self.t
+
+    def sleep(self, seconds):
+        self.t += max(seconds, 0.0005)
+
+    def module(self):
+        return types.SimpleNamespace(time=self.now, monotonic=self.now,
+                                     perf_counter=self.now, sleep=self.sleep)
+
+
+@pytest.fixture
+def clock(monkeypatch):
+    c = _Clock()
+    monkeypatch.setattr("src.display_controller.time", c.module())
+    return c
+
+
+class _Locks:
+    """get_plugin_lock for one plugin, whose lock the test can hold."""
+
+    def __init__(self):
+        self.lock = threading.Lock()
+
+    def __call__(self, plugin_id):
+        return self.lock
+
+
+@pytest.fixture
+def held(test_display_controller):
+    c = test_display_controller
+    locks = _Locks()
+    c.plugin_manager.get_plugin_lock = locks
+    c.plugin_manager._warn_rate_limited = MagicMock()
+    c.plugin_manager.health_tracker = MagicMock()
+    c._display_hold = None
+    return c, locks.lock
+
+
+def _plugin(plugin_id):
+    p = MagicMock()
+    p.plugin_id = plugin_id
+    p.display.return_value = True
+    return p
+
+
+class TestTheDisplayHoldReport:
+    def test_a_long_hold_is_reported_when_it_ends(self, held, clock):
+        c, lock = held
+        ticker = _plugin("ticker")
+        lock.acquire()                         # update() running
+        assert c._display_once(ticker, "ticker", False, report_hold=True) is True
+        clock.t += 0.2
+        assert c._display_once(ticker, "ticker", False, report_hold=True) is True
+        assert ticker.display.call_count == 0
+        c.plugin_manager._warn_rate_limited.assert_not_called()
+        clock.t += 0.2
+        lock.release()                         # update() done
+        c._display_once(ticker, "ticker", False, report_hold=True)
+        assert ticker.display.call_count == 1
+        key, message, plugin_id, ms = c.plugin_manager._warn_rate_limited.call_args[0]
+        assert key == "display-hold:ticker" and plugin_id == "ticker"
+        assert "held" in message and ms == pytest.approx(400.0)
+        c.plugin_manager.health_tracker.record_busy_skip.assert_called_once_with(
+            "ticker", "display hold", pytest.approx(0.4))
+
+    def test_a_short_hold_is_not(self, held, clock):
+        c, lock = held
+        ticker = _plugin("ticker")
+        lock.acquire()
+        c._display_once(ticker, "ticker", False, report_hold=True)
+        clock.t += 0.1
+        lock.release()
+        c._display_once(ticker, "ticker", False, report_hold=True)
+        c.plugin_manager._warn_rate_limited.assert_not_called()
+        c.plugin_manager.health_tracker.record_busy_skip.assert_not_called()
+
+    def test_a_hold_that_ends_on_another_plugins_screen_is_not_blamed_on_it(
+            self, held, clock):
+        c, lock = held
+        lock.acquire()
+        c._display_once(_plugin("ticker"), "ticker", False, report_hold=True)
+        clock.t += 1.0
+        lock.release()
+        c._display_once(_plugin("clock"), "clock", False, report_hold=True)
+        c.plugin_manager._warn_rate_limited.assert_not_called()
+        assert c._display_hold is None
+
+    def test_frames_that_draw_report_nothing(self, held, clock):
+        c, _lock = held
+        ticker = _plugin("ticker")
+        for _ in range(5):
+            c._display_once(ticker, "ticker", False, report_hold=True)
+            clock.t += 0.5
+        c.plugin_manager._warn_rate_limited.assert_not_called()
+
+    def test_the_1hz_loop_reports_no_holds(self, held, clock):
+        # A static screen's frames are a second apart: one skipped frame is
+        # not a measured hold, and nothing on the panel froze. (On ledpi the
+        # first version reported every such skip as "held 1000 ms".)
+        c, lock = held
+        board = _plugin("board")
+        lock.acquire()
+        c._display_once(board, "board", False)
+        clock.t += 1.0
+        lock.release()
+        c._display_once(board, "board", False)
+        c.plugin_manager._warn_rate_limited.assert_not_called()
+        c.plugin_manager.health_tracker.record_busy_skip.assert_not_called()
+
+    def test_a_run_left_open_is_dropped_by_a_1hz_frame(self, held, clock):
+        c, lock = held
+        ticker = _plugin("ticker")
+        lock.acquire()
+        c._display_once(ticker, "ticker", False, report_hold=True)
+        lock.release()
+        c._display_once(ticker, "ticker", False)        # the 1 Hz loop draws
+        assert c._display_hold is None
+        clock.t += 5.0
+        c._display_once(ticker, "ticker", False, report_hold=True)
+        c.plugin_manager._warn_rate_limited.assert_not_called()

test/test_frame_timing.py

@@ -807,54 +807,3 @@ def test_a_process_with_the_gc_monitor_exits_cleanly():
     assert proc.returncode == 0, proc.stderr
     assert "Exception ignored" not in proc.stderr
     assert "installed at exit: False" in proc.stdout
-
-
-SLOW = 1 / 110.0  # a panel that cannot reach a 120 Hz cap
-
-
-def _windows(recorder, n, interval, start=0.0):
-    for i in range(n):
-        _feed(recorder, [interval] * 200, start=start + 50.0 * i)
-        _aggregate(recorder)
-
-
-def _shortfall_warnings(caplog):
-    return [r for r in caplog.records
-            if r.name == "src.common.frame_timing" and "Limit Refresh Rate" in r.getMessage()]
-
-
-def test_a_panel_slower_than_its_cap_is_reported_once(tmp_path, caplog):
-    r = _recorder(tmp_path)
-    r.plan_refresh(120.0)
-    caplog.set_level("WARNING")
-    _windows(r, 3, SLOW)          # adopted on the 2nd window, checked on the 4th
-    assert _shortfall_warnings(caplog) == []
-    _windows(r, 3, SLOW, start=1000.0)
-    warnings = _shortfall_warnings(caplog)
-    assert len(warnings) == 1
-    assert "about 110 Hz" in warnings[0].getMessage()
-    assert "to 100 Hz" in warnings[0].getMessage()
-
-
-def test_a_panel_that_reaches_its_cap_is_not_reported(tmp_path, caplog):
-    r = _recorder(tmp_path)
-    r.plan_refresh(100.0)
-    caplog.set_level("WARNING")
-    _windows(r, 6, PERIOD)
-    assert _shortfall_warnings(caplog) == []
-
-
-def test_without_a_planned_rate_nothing_is_checked(tmp_path, caplog):
-    # The emulator and the fallback canvas: DisplayManager never calls
-    # plan_refresh(), since their frames are not paced by a panel.
-    r = _recorder(tmp_path)
-    caplog.set_level("WARNING")
-    _windows(r, 6, SLOW)
-    assert _shortfall_warnings(caplog) == []
-
-
-def test_the_snapshot_records_the_planned_rate(tmp_path):
-    r = _recorder(tmp_path)
-    assert r.snapshot()["planned_refresh_hz"] is None
-    r.plan_refresh(120.0)
-    assert r.snapshot()["planned_refresh_hz"] == 120.0

test/test_scroll_config.py

@@ -21,7 +21,6 @@ from src.common.scroll_config import (  # noqa: E402
     refresh_hz_from_config,
     resolve,
 )
-from src.common import scroll_config  # noqa: E402
 
 
 class FakeHelper:
@@ -505,46 +504,3 @@ class TestSpeedAdvice:
         got = solve_crisp(50, 125.74)
         assert got.steppiness == "smooth"
         assert got.pixels_per_frame == 1
-
-
-class TestRefreshShortfall:
-    """A panel that cannot reach its cap runs every scroll slow."""
-
-    def test_the_ledmatrix_rig_is_told_to_cap_at_100(self):
-        # Pi 4, 2x128x64 on adafruit-hat-pwm under a 120 Hz cap: measured
-        # 107.6-113.1 Hz, and frame_timing reports the fast end.
-        s = scroll_config.refresh_shortfall(113.1, 120)
-        assert s == {"measured_hz": 113.1, "planned_hz": 120.0,
-                     "suggested_cap_hz": 100, "slow_percent": 6}
-
-    def test_a_panel_that_holds_its_cap_is_fine(self):
-        assert scroll_config.refresh_shortfall(99.95, 100) is None
-        assert scroll_config.refresh_shortfall(97.5, 100) is None
-
-    def test_a_panel_that_beats_its_cap_is_fine(self):
-        assert scroll_config.refresh_shortfall(125.7, 120) is None
-
-    def test_nothing_measured_says_nothing(self):
-        assert scroll_config.refresh_shortfall(None, 120) is None
-        assert scroll_config.refresh_shortfall(0, 120) is None
-        assert scroll_config.refresh_shortfall("fast", 120) is None
-
-    def test_the_suggestion_leaves_headroom_under_the_measurement(self):
-        assert scroll_config.holdable_cap(113.1) == 100
-        assert scroll_config.holdable_cap(95.0) == 90
-        # 5% under 105 is 99.75: 100 would sit inside the panel's drift.
-        assert scroll_config.holdable_cap(105.0) == 90
-        assert scroll_config.holdable_cap(9.0) is None
-        assert scroll_config.holdable_cap(None) is None
-
-    def test_the_log_line_names_the_cap_to_use(self):
-        text = scroll_config.describe_refresh_shortfall(
-            scroll_config.refresh_shortfall(113.1, 120))
-        assert "about 113 Hz" in text and "120 Hz" in text
-        assert "6% slower" in text
-        assert "Set Limit Refresh Rate to 100 Hz" in text
-
-    def test_no_suggestion_for_a_panel_too_slow_for_any_cap(self):
-        text = scroll_config.describe_refresh_shortfall(
-            scroll_config.refresh_shortfall(9.0, 100))
-        assert "Set Limit Refresh Rate" not in text

test/web_interface/test_api_v3_refresh_rate.py

@@ -1,63 +0,0 @@
-"""GET /api/v3/config/refresh-rate: the cap, the measured rate, a cap to hold."""
-import json
-from unittest.mock import MagicMock
-
-import pytest
-from flask import Flask
-
-from web_interface.blueprints.api_v3 import api_v3
-
-
-@pytest.fixture
-def client(monkeypatch, tmp_path):
-    stats = tmp_path / "stats.json"
-    monkeypatch.setattr("src.common.frame_timing.default_stats_path", lambda: str(stats))
-    manager = MagicMock()
-    manager.load_config.return_value = {
-        "display": {"hardware": {"limit_refresh_rate_hz": 120}}}
-    monkeypatch.setattr(api_v3, "config_manager", manager, raising=False)
-    app = Flask(__name__)
-    app.register_blueprint(api_v3, url_prefix="/api/v3")
-    c = app.test_client()
-    c.stats_path = stats
-    return c
-
-
-def _get(client):
-    body = client.get("/api/v3/config/refresh-rate").get_json()
-    assert body["status"] == "success"
-    return body["data"]
-
-
-def test_nothing_measured_yet(client):
-    data = _get(client)
-    assert data == {"planned_hz": 120.0, "measured_hz": None, "shortfall": None}
-
-
-def test_a_panel_short_of_its_cap_gets_a_cap_it_can_hold(client):
-    client.stats_path.write_text(json.dumps(
-        {"measured_refresh_hz": 110.4, "planned_refresh_hz": 120.0}))
-    data = _get(client)
-    assert data["measured_hz"] == 110.4
-    assert data["shortfall"]["suggested_cap_hz"] == 100
-    assert data["shortfall"]["slow_percent"] == 8
-
-
-def test_a_panel_at_its_cap_has_no_shortfall(client):
-    client.stats_path.write_text(json.dumps(
-        {"measured_refresh_hz": 121.3, "planned_refresh_hz": 120.0}))
-    assert _get(client)["shortfall"] is None
-
-
-def test_a_file_written_under_another_cap_is_stale(client):
-    # The cap was changed to 120 but the display still runs under 100 Hz.
-    client.stats_path.write_text(json.dumps(
-        {"measured_refresh_hz": 99.9, "planned_refresh_hz": 100.0}))
-    data = _get(client)
-    assert data["measured_hz"] is None
-    assert data["shortfall"] is None
-
-
-def test_a_file_from_a_display_too_old_to_record_its_cap_still_counts(client):
-    client.stats_path.write_text(json.dumps({"measured_refresh_hz": 110.4}))
-    assert _get(client)["shortfall"]["suggested_cap_hz"] == 100

test/web_interface/test_starlark_pixlet_routes.py

@@ -26,8 +26,15 @@ import pytest
 
 
 @pytest.fixture
-def client():
+def client(monkeypatch):
+    from web_interface import app as web_app
     from web_interface.app import app
+    # The captive-portal before_request hook shells out to systemctl/nmcli
+    # whenever its 30s cache is cold, so on a Linux host whether a request
+    # here runs subprocess depended on how long ago the previous one was --
+    # and several tests below stub subprocess. Pin it: no test in this file
+    # is about AP mode.
+    monkeypatch.setattr(web_app, 'is_ap_mode_active', lambda: False)
     app.config['TESTING'] = True
     with app.test_client() as c:
         yield c
@@ -1136,12 +1143,23 @@ class TestPixletEditorHostDefaultsButDoesNotOverride:
                 captured['env'] = env
             return FakeProcess()
 
+        # Swap the route module's own ``subprocess`` binding, not the shared
+        # ``subprocess.Popen``: patching the attribute on the real module is
+        # process-wide, and the app's before_request hook (the captive-portal
+        # check) runs ``subprocess.run`` -- ``with Popen(...)`` -- whenever its
+        # 30s AP-mode cache is cold on a host with systemctl. On the Linux CI
+        # runner that handed it this FakeProcess and 500'd the request, but
+        # only when the previous request was more than 30s earlier.
+        fake_subprocess = types.ModuleType('subprocess')
+        fake_subprocess.__dict__.update(mod.subprocess.__dict__)
+        fake_subprocess.Popen = fake_popen
+
         with patch.object(mod, '_validate_starlark_app_path',
                           return_value=(app_dir, None)), \
              patch.object(mod, '_PIXLET_EDITOR_SCRIPT', script), \
              patch.object(mod, '_PIXLET_EDITOR_STATE', state_file), \
              patch.object(mod, '_find_pixlet_binary', return_value='/usr/bin/pixlet'), \
-             patch.object(mod.subprocess, 'Popen', side_effect=fake_popen), \
+             patch.object(mod, 'subprocess', fake_subprocess), \
              patch.dict(os.environ):
             if operator_host is None:
                 os.environ.pop('PIXLET_EDITOR_HOST', None)

web_interface/blueprints/api_v3/config.py

@@ -158,16 +158,11 @@ def _panel_refresh_hz(config):
     cap = scroll_config.refresh_hz_from_config(config)
     try:
         with open(frame_timing.default_stats_path(), encoding='utf-8') as fh:
-            stats = json.load(fh)
-        measured = float(stats.get('measured_refresh_hz') or 0)
-        planned = float(stats.get('planned_refresh_hz') or 0)
+            measured = float(json.load(fh).get('measured_refresh_hz') or 0)
     except (OSError, ValueError, TypeError, AttributeError):
-        measured = planned = 0.0
-    # Reject a stale file from a previous hardware config: one written under
-    # another cap (the display has not restarted since it changed), or, from
-    # a display too old to record its cap, a measurement far off this one.
-    if planned and abs(planned - cap) > 0.5:
         measured = 0.0
+    # Reject a stale file from a previous hardware config: a measurement far
+    # off the cap says the config changed since it was written.
     if measured > 0 and 0.5 * cap <= measured <= 1.5 * cap:
         return measured, 'measured'
     return cap, 'configured'
@@ -194,29 +189,6 @@ def get_scroll_speed_advice():
     return jsonify({'status': 'success', 'data': advice})
 
 
-@api_v3.route('/config/refresh-rate', methods=['GET'])
-def get_refresh_rate():
-    """The refresh cap, what the panel measured, and a cap it can hold.
-
-    Backs the hint under the Display tab's Limit Refresh Rate field. Scroll
-    speeds are solved against the cap, so a panel that cannot reach it runs
-    every scroll slow; ``shortfall`` (None when the panel keeps up, or nothing
-    has been measured yet) says by how much and suggests a cap.
-    """
-    from src.common import scroll_config
-    if not api_v3.config_manager:
-        return jsonify({'status': 'error', 'message': 'Config manager not initialized'}), 500
-    config = api_v3.config_manager.load_config()
-    planned = scroll_config.refresh_hz_from_config(config)
-    hz, source = _panel_refresh_hz(config)
-    measured = hz if source == 'measured' else None
-    return jsonify({'status': 'success', 'data': {
-        'planned_hz': planned,
-        'measured_hz': round(measured, 1) if measured else None,
-        'shortfall': scroll_config.refresh_shortfall(measured, planned),
-    }})
-
-
 @api_v3.route('/config/schedule', methods=['GET'])
 def get_schedule_config():
     """Get current schedule configuration"""

web_interface/templates/v3/partials/display.html

@@ -318,7 +318,6 @@
                            min="0"
                            max="1000"
                            class="form-control">
-                    <p id="limit_refresh_rate_hz_hint" class="mt-1 text-xs text-amber-700" aria-live="polite"></p>
                 </div>
             </div>
 
@@ -916,41 +915,6 @@ document.getElementById('brightness').addEventListener('input', function() {
         });
     }
 
-    // Say so when the panel cannot reach its refresh cap. Scroll speeds are
-    // worked out against the cap, so every scroll then runs slow, and the
-    // display has measured a cap the panel can hold.
-    (function refreshRateHint() {
-        const hint = document.getElementById('limit_refresh_rate_hz_hint');
-        const input = document.getElementById('limit_refresh_rate_hz');
-        if (!hint || !input) return;
-        fetch('/api/v3/config/refresh-rate')
-            .then(function(r) { return r.json(); })
-            .then(function(body) {
-                const s = body.status === 'success' && body.data.shortfall;
-                hint.textContent = '';
-                if (!s) return;
-                hint.appendChild(document.createTextNode(
-                    'This panel refreshes at about ' + Math.round(s.measured_hz) +
-                    ' Hz, below this ' + Math.round(s.planned_hz) + ' Hz cap, so scrolls run about ' +
-                    s.slow_percent + '% slower than set.' + (s.suggested_cap_hz ? ' ' : '')));
-                if (!s.suggested_cap_hz) return;
-                const btn = document.createElement('button');
-                btn.type = 'button';
-                btn.className = 'underline font-medium';
-                btn.textContent = 'Use ' + s.suggested_cap_hz + ' Hz';
-                btn.addEventListener('click', function() {
-                    input.value = s.suggested_cap_hz;
-                    input.dispatchEvent(new Event('input', {bubbles: true}));
-                    input.dispatchEvent(new Event('change', {bubbles: true}));
-                    hint.textContent = 'Save, then restart the display, to apply ' +
-                        s.suggested_cap_hz + ' Hz.';
-                });
-                hint.appendChild(btn);
-                hint.appendChild(document.createTextNode(', a cap it can hold.'));
-            })
-            .catch(function() { hint.textContent = ''; });
-    })();
-
     // Declared before first use: let is not hoisted usably.
     let scrollHintTimer = null;
     let scrollHintSeq = 0;