better-rtplot 0.4.6__tar.gz → 0.4.8__tar.gz

{better_rtplot-0.4.6 → better_rtplot-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-rtplot
-Version: 0.4.6
+Version: 0.4.8
 Summary: 
 License: GPL V3.0
 Author: jmontp

{better_rtplot-0.4.6 → better_rtplot-0.4.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "better-rtplot"
-version = "0.4.6"
+version = "0.4.8"
 description = ""
 authors = ["jmontp <jmontp@umich.edu>"]
 license = "GPL V3.0"

{better_rtplot-0.4.6 → better_rtplot-0.4.8}/rtplot/client.py

@@ -538,6 +538,12 @@ def poll_controls():
             if plot_desc_dict is not None:
                 socket.send_string(SENDING_PLOT_UPDATE)
                 socket.send_json(plot_desc_dict)
+                # Surface a one-line confirmation so the user can see in
+                # their script log that the recovery handshake worked.
+                # If they never see this after clicking Reconnect, the
+                # PUSH/PULL channel back from the server isn't wired —
+                # check that poll_controls() is actually being called.
+                print("rtplot.client: resent cached initialize_plots() config")
 
     buttons = _control_button_events
     _control_button_events = []

{better_rtplot-0.4.6 → better_rtplot-0.4.8}/rtplot/server_browser.py

@@ -215,7 +215,13 @@ RECEIVED_DISPLAY = 4
 BIND_ME_ID = "bind_me"
 BIND_ME_NAME = "Shared - Bind to me"
 
-TABS_FILE = os.path.join(os.path.expanduser("~"), ".rtplot", "tabs.json")
+# Path to the persisted tabs JSON. Honors RTPLOT_TABS_FILE so tests
+# (and operators with multi-user setups) can override without symlinking
+# their HOME directory or losing access to ~/.local site-packages.
+TABS_FILE = os.environ.get(
+    "RTPLOT_TABS_FILE",
+    os.path.join(os.path.expanduser("~"), ".rtplot", "tabs.json"),
+)
 
 zmq_ctx = zmq.asyncio.Context()
 
@@ -306,6 +312,12 @@ class Tab:
     data_rate_hz: float = 0.0
     _last_rx_ts: float = 0.0
 
+    # When the most recent client-supplied config failed to parse we
+    # stash the reason + a unix timestamp so the browser can surface
+    # "your last config was rejected at HH:MM:SS" instead of just
+    # silently rendering nothing. Cleared on the next successful parse.
+    last_config_error: Optional[dict] = None
+
     def ensure_buffer(self):
         if self.buffer is None:
             self.buffer = np.zeros((INITIAL_NUM_TRACES, MAX_LOCAL_STORAGE))
@@ -344,6 +356,7 @@ def tab_public(t: Tab) -> dict:
         "endpoint": t.endpoint,
         "status": t.status,
         "error": t.error,
+        "last_config_error": t.last_config_error,
     }
 
 
@@ -595,43 +608,67 @@ def _remove_ws(ws):
 def _open_tab_sockets(tab: Tab):
     """Open ``tab``'s data + control sockets according to its mode.
 
-    On failure, sets tab.status="error" and tab.error=<reason>; the tab
-    stays in the list but won't stream until re-opened.
+    For bind tabs, the just-closed sockets may leave the OS-level port
+    in a transient state for a few hundred ms (especially on Windows /
+    WSL). We retry the bind with a small backoff so the user-visible
+    Reconnect button doesn't fail spuriously the very first time. On
+    sustained failure we set tab.status="error" + tab.error=<reason>;
+    the tab stays in the list but won't stream until re-opened.
     """
     # Close any prior sockets first (e.g. on retry).
     _close_tab_sockets(tab)
 
-    try:
-        data = zmq_ctx.socket(zmq.SUB)
-        data.setsockopt_string(zmq.SUBSCRIBE, "")
-        ctrl = zmq_ctx.socket(zmq.PUSH)
-        ctrl.setsockopt(zmq.SNDHWM, 1000)
-        ctrl.setsockopt(zmq.LINGER, 0)
-
-        if tab.mode == "bind":
-            data.bind(f"tcp://*:{ZMQ_DEFAULT_PORT}")
-            ctrl.bind(f"tcp://*:{ZMQ_CONTROL_PORT}")
-            tab.endpoint = f"*:{ZMQ_DEFAULT_PORT}"
-            print(f"[{tab.id}] ZMQ: bound on tcp://*:{ZMQ_DEFAULT_PORT}")
-        else:
-            data_ep, label = _normalize_connect_target(tab.endpoint)
-            data.connect(data_ep)
-            ctrl_ep, _ = _normalize_connect_target(
-                _control_target_from_data(tab.endpoint), port=ZMQ_CONTROL_PORT
-            )
-            ctrl.connect(ctrl_ep)
-            tab.endpoint = label
-            print(f"[{tab.id}] ZMQ: connected to {data_ep} (ctrl {ctrl_ep})")
+    last_exc: Exception | None = None
+    attempts = 4 if tab.mode == "bind" else 1
+    for attempt in range(attempts):
+        try:
+            data = zmq_ctx.socket(zmq.SUB)
+            data.setsockopt_string(zmq.SUBSCRIBE, "")
+            data.setsockopt(zmq.LINGER, 0)
+            ctrl = zmq_ctx.socket(zmq.PUSH)
+            ctrl.setsockopt(zmq.SNDHWM, 1000)
+            ctrl.setsockopt(zmq.LINGER, 0)
+
+            if tab.mode == "bind":
+                data.bind(f"tcp://*:{ZMQ_DEFAULT_PORT}")
+                ctrl.bind(f"tcp://*:{ZMQ_CONTROL_PORT}")
+                tab.endpoint = f"*:{ZMQ_DEFAULT_PORT}"
+                print(f"[{tab.id}] ZMQ: bound on tcp://*:{ZMQ_DEFAULT_PORT}")
+            else:
+                data_ep, label = _normalize_connect_target(tab.endpoint)
+                data.connect(data_ep)
+                ctrl_ep, _ = _normalize_connect_target(
+                    _control_target_from_data(tab.endpoint), port=ZMQ_CONTROL_PORT
+                )
+                ctrl.connect(ctrl_ep)
+                tab.endpoint = label
+                print(f"[{tab.id}] ZMQ: connected to {data_ep} (ctrl {ctrl_ep})")
 
-        tab.data_sock = data
-        tab.ctrl_sock = ctrl
-        tab.status = "idle"
-        tab.error = None
-    except Exception as exc:  # noqa: BLE001
-        tab.status = "error"
-        tab.error = str(exc)
-        print(f"[{tab.id}] ZMQ open failed: {exc}")
-        _close_tab_sockets(tab)
+            tab.data_sock = data
+            tab.ctrl_sock = ctrl
+            tab.status = "idle"
+            tab.error = None
+            return
+        except Exception as exc:  # noqa: BLE001
+            last_exc = exc
+            # Drop the half-built sockets before retrying so we don't
+            # leak descriptors and so the next attempt re-takes the port.
+            try: data.close(0)
+            except Exception: pass
+            try: ctrl.close(0)
+            except Exception: pass
+            if attempt < attempts - 1:
+                wait = 0.15 * (attempt + 1)
+                print(
+                    f"[{tab.id}] ZMQ open attempt {attempt + 1}/{attempts}"
+                    f" failed ({exc}); retrying in {wait:.2f}s"
+                )
+                time.sleep(wait)
+
+    tab.status = "error"
+    tab.error = str(last_exc) if last_exc is not None else "unknown error"
+    print(f"[{tab.id}] ZMQ open failed after {attempts} attempts: {last_exc}")
+    _close_tab_sockets(tab)
 
 
 def _close_tab_sockets(tab: Tab):
@@ -711,8 +748,30 @@ async def zmq_receiver(tab: Tab):
         tab._last_rx_ts = now
 
         if category == RECEIVED_PLOT_UPDATE:
-            cfg = await sock.recv_json(object_pairs_hook=OrderedDict)
-            parse_config(tab, cfg)
+            # Decode + parse are wrapped so a malformed config doesn't kill
+            # the receiver task. We stash the failure on the tab so the
+            # browser can show "your last config was rejected at HH:MM:SS"
+            # instead of looking like nothing happened. Existing valid
+            # state (if any) is preserved on parse failure.
+            try:
+                cfg = await sock.recv_json(object_pairs_hook=OrderedDict)
+            except Exception as exc:  # noqa: BLE001
+                msg = f"Could not decode config JSON: {type(exc).__name__}: {exc}"
+                print(f"[{tab.id}] {msg}")
+                tab.last_config_error = {"message": msg, "timestamp": time.time()}
+                await broadcast_tab(tab.id)
+                continue
+
+            try:
+                parse_config(tab, cfg)
+            except Exception as exc:  # noqa: BLE001
+                msg = f"Configuration rejected: {type(exc).__name__}: {exc}"
+                print(f"[{tab.id}] {msg}")
+                tab.last_config_error = {"message": msg, "timestamp": time.time()}
+                await broadcast_tab(tab.id)
+                continue
+
+            tab.last_config_error = None  # clear: this one was good
             tab.config_dict = cfg
             tab.config_message = build_config_message(tab, cfg)
             tab.initialized = True
@@ -972,24 +1031,44 @@ async def _request_config_resend(tab: "Tab"):
     the cached config so the plot picks back up without the user having
     to restart their script.
 
-    Retries on a brief schedule because the client's PULL socket may need
-    a moment to auto-reconnect to the freshly bound PUSH socket — a
-    one-shot DONTWAIT send to a peer-less PUSH gets silently dropped.
-    Stops early once we see ``tab.initialized`` flip to True (the client
-    has answered) so we don't spam.
+    Retries over a ~10 s window because:
+      * the client's PULL socket may need a moment to auto-reconnect to
+        the freshly bound PUSH socket — especially over a WAN/SSH link;
+      * a slow user loop may only call poll_controls() once per second,
+        so the message can sit unread in the PULL queue for a while;
+      * the client may not be running at all (no peer), in which case
+        the queued message is just dropped when the next reconnect happens.
+    Stops early once tab.initialized flips True (the client answered).
     """
-    for i, delay in enumerate((0.4, 1.0, 2.0)):
+    schedule = (0.3, 0.7, 1.5, 2.5, 5.0)  # cumulative ~10 s
+    started_initialized = tab.initialized
+    for i, delay in enumerate(schedule):
         await asyncio.sleep(delay)
         if tab.ctrl_sock is None:
             return
-        if i > 0 and tab.initialized:
+        if i > 0 and tab.initialized and not started_initialized:
             return
         try:
             await tab.ctrl_sock.send_json(
                 {"type": "resend_config"}, flags=zmq.DONTWAIT
             )
-        except (zmq.Again, zmq.ZMQError):
-            pass
+            if DEBUG_TEXT_ENABLED:
+                print(f"[{tab.id}] resend_config sent (attempt {i + 1}/{len(schedule)})")
+        except (zmq.Again, zmq.ZMQError) as exc:
+            if DEBUG_TEXT_ENABLED:
+                print(
+                    f"[{tab.id}] resend_config attempt {i + 1}/{len(schedule)}"
+                    f" failed: {exc} (likely no peer connected yet)"
+                )
+    # If we asked the client to re-init but nothing came back, surface
+    # a hint so the user knows where to look. Common causes: the client
+    # is on rtplot < 0.4.6 (no resend_config handler), or its loop never
+    # calls poll_controls(), or there's no client running at all.
+    if not started_initialized and not tab.initialized:
+        print(
+            f"[{tab.id}] no config received after resend_config nudges."
+            " Is the client running rtplot >= 0.4.6 and calling poll_controls()?"
+        )
 
 
 async def reconnect_tab(tab_id: str):

{better_rtplot-0.4.6 → better_rtplot-0.4.8}/rtplot/static/index.html

@@ -67,6 +67,13 @@
   .plot-wrap { background: #fff; border: 1px solid #ddd; border-radius: 4px; padding: 8px; flex: 1 1 auto; min-width: 320px; }
   .plot-title { font-size: 13px; font-weight: 600; margin: 0 0 4px 4px; color: #333; }
   #empty-state { padding: 28px 32px; color: #888; font-size: calc(14px * var(--ui-scale)); font-style: italic; }
+  /* Persistent banner the server raises when a client-supplied plot
+     config fails to parse — the user used to be left guessing why
+     nothing rendered; now they get the reason + a local timestamp. */
+  .config-error-banner { margin: 12px 12px 0 12px; padding: 10px 14px; background: #fce8e8; color: #8a1a1a; border: 1px solid #f0c2c2; border-left: 4px solid #d24a4a; border-radius: 4px; font-size: calc(13px * var(--ui-scale)); }
+  .config-error-banner .ce-title { font-weight: 600; margin-right: 8px; }
+  .config-error-banner .ce-when { color: #6b1818; opacity: 0.8; font-family: monospace; font-size: calc(12px * var(--ui-scale)); }
+  .config-error-banner .ce-msg { display: block; margin-top: 4px; font-family: monospace; font-size: calc(12px * var(--ui-scale)); white-space: pre-wrap; word-break: break-word; }
   :root { --ctrl-unit-h: 38px; --ui-scale: 1; }
   .ctrl-row { display: flex; gap: 12px; align-items: center; padding: 10px 14px; background: #fff; border: 1px solid #ddd; border-radius: 4px; flex-wrap: wrap; }
   .ctrl-item { display: flex; align-items: center; gap: 6px; }
@@ -187,6 +194,7 @@
       <div id="res-unavail" class="res-unavail" style="display:none;">psutil not installed &mdash; pip install psutil for live stats</div>
     </div>
   </div>
+  <div id="config-error-banner" class="config-error-banner" style="display:none"></div>
   <div id="plots" class="row"></div>
   <script src="/static/uPlot.iife.min.js"></script>
   <script src="/static/katex/katex.min.js"></script>
@@ -210,6 +218,43 @@
         return 'rgb(0,0,0)';
       }
 
+      const configErrorBanner = document.getElementById('config-error-banner');
+
+      function fmtLocalTimestamp(unixSeconds) {
+        const d = new Date(unixSeconds * 1000);
+        const pad = (n) => String(n).padStart(2, '0');
+        return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+               `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+      }
+
+      function applyConfigErrorBanner() {
+        const t = activeTab && knownTabs[activeTab];
+        const err = t && t.last_config_error;
+        if (!err) {
+          configErrorBanner.style.display = 'none';
+          configErrorBanner.innerHTML = '';
+          return;
+        }
+        // Build with textContent on the leaf nodes so user-controlled
+        // strings (the error message) can't inject HTML.
+        configErrorBanner.innerHTML = '';
+        const head = document.createElement('div');
+        const title = document.createElement('span');
+        title.className = 'ce-title';
+        title.textContent = 'Last configuration was rejected';
+        head.appendChild(title);
+        const when = document.createElement('span');
+        when.className = 'ce-when';
+        when.textContent = `at ${fmtLocalTimestamp(err.timestamp)}`;
+        head.appendChild(when);
+        configErrorBanner.appendChild(head);
+        const body = document.createElement('span');
+        body.className = 'ce-msg';
+        body.textContent = err.message || '';
+        configErrorBanner.appendChild(body);
+        configErrorBanner.style.display = '';
+      }
+
       // ---- LaTeX rendering ($...$ inline, $$...$$ display) ----
       // KaTeX's auto-render walks an element's text nodes looking for the
       // configured delimiters, so plain labels without `$` are completely
@@ -1111,6 +1156,7 @@
         showEmptyState('Loading tab \u2026');
         const t = knownTabs[id];
         setZmqMode(t.mode, t.endpoint);
+        applyConfigErrorBanner();
         sendCtrl({ type: 'tab_subscribe', id: id });
       }
 
@@ -1183,6 +1229,7 @@
               if (activeTab) {
                 const t = knownTabs[activeTab];
                 setZmqMode(t.mode, t.endpoint);
+                applyConfigErrorBanner();
                 sendCtrl({ type: 'tab_subscribe', id: activeTab });
                 showEmptyState('Loading tab \u2026');
               }
@@ -1193,6 +1240,7 @@
                 renderTabs();
                 if (msg.tab.id === activeTab) {
                   setZmqMode(msg.tab.mode, msg.tab.endpoint);
+                  applyConfigErrorBanner();
                 }
               }
             } else if (msg.type === 'tab_removed') {