better-rtplot 0.4.5__tar.gz → 0.4.7__tar.gz

{better_rtplot-0.4.5 → better_rtplot-0.4.7}/PKG-INFO

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

{better_rtplot-0.4.5 → better_rtplot-0.4.7}/pyproject.toml

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

{better_rtplot-0.4.5 → better_rtplot-0.4.7}/rtplot/client.py

@@ -25,6 +25,13 @@ control_socket.setsockopt(zmq.RCVHWM, 1000)
 _control_slider_values = {}
 _control_button_events = []
 
+# Cached payload of the most recent initialize_plots() call. The server
+# uses this to recover from its own crashes: when its tab loses the
+# config, it pushes a "resend_config" control event over the return
+# channel, and poll_controls() re-PUBs this dict so the plot reattaches
+# without the user restarting their script. None until first call.
+plot_desc_dict = None
+
 #Global variable to keep track of last connected address
 # default is fixed publisher mode, therefore you don't connect
 # to an address
@@ -506,6 +513,13 @@ def poll_controls():
         (cleared after this call).
 
     Call this from your tight loop before computing the next sample.
+
+    Also transparently handles ``resend_config`` requests from the server:
+    if the server crashed and reconnected (or the user clicked the
+    Reconnect button on a tab), it asks us to re-publish the cached
+    initialize_plots() payload so the plot rewires without the user
+    restarting their script. The request is consumed silently — the
+    returned ControlState only ever contains slider/button events.
     """
     global _control_button_events
     while True:
@@ -520,6 +534,10 @@ def poll_controls():
             _control_button_events.append(event.get("id"))
         elif evtype == "slider":
             _control_slider_values[event.get("id")] = float(event.get("value", 0.0))
+        elif evtype == "resend_config":
+            if plot_desc_dict is not None:
+                socket.send_string(SENDING_PLOT_UPDATE)
+                socket.send_json(plot_desc_dict)
 
     buttons = _control_button_events
     _control_button_events = []

{better_rtplot-0.4.5 → better_rtplot-0.4.7}/rtplot/server_browser.py

@@ -306,6 +306,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 +350,7 @@ def tab_public(t: Tab) -> dict:
         "endpoint": t.endpoint,
         "status": t.status,
         "error": t.error,
+        "last_config_error": t.last_config_error,
     }
 
 
@@ -711,8 +718,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
@@ -921,6 +950,10 @@ async def create_connect_tab(
     tabs[t.id] = t
     _open_tab_sockets(t)
     t.receiver_task = asyncio.create_task(zmq_receiver(t))
+    # If the client at the other end is already running and only called
+    # initialize_plots() once at its startup, this nudges it to resend
+    # the cached config so the new tab populates without a script restart.
+    asyncio.create_task(_request_config_resend(t))
     if persist:
         save_persisted_tabs()
     await broadcast_tab_list()
@@ -956,13 +989,47 @@ async def rename_tab(tab_id: str, new_name: str):
     await broadcast_tab(tab_id)
 
 
+async def _request_config_resend(tab: "Tab"):
+    """Nudge a still-running client to re-send its initialize_plots() payload.
+
+    The common scenario: the server crashed (or was restarted) mid-session
+    and lost the plot config it received the first time the client called
+    ``initialize_plots()``. The client is still happily streaming data,
+    but the new server has nothing to plot it on. This sends a
+    ``{"type": "resend_config"}`` control event over the tab's PUSH
+    socket; the client's poll_controls() loop intercepts it and re-sends
+    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.
+    """
+    for i, delay in enumerate((0.4, 1.0, 2.0)):
+        await asyncio.sleep(delay)
+        if tab.ctrl_sock is None:
+            return
+        if i > 0 and tab.initialized:
+            return
+        try:
+            await tab.ctrl_sock.send_json(
+                {"type": "resend_config"}, flags=zmq.DONTWAIT
+            )
+        except (zmq.Again, zmq.ZMQError):
+            pass
+
+
 async def reconnect_tab(tab_id: str):
     """Close and reopen ``tab_id``'s sockets, restart its receiver task.
 
     The tab's buffer and plot config are preserved — if the sender on
     the other side is still running the same stream we avoid a visible
-    flash to empty. A new config from the sender will replace the state
-    via the normal RECEIVED_PLOT_UPDATE path.
+    flash to empty. After the sockets come back up we ask the (likely
+    still-running) client to re-send its plot config so the connection
+    recovers cleanly even if the server itself restarted in the
+    meantime.
     """
     t = tabs.get(tab_id)
     if t is None:
@@ -976,6 +1043,7 @@ async def reconnect_tab(tab_id: str):
     t.data_rate_hz = 0.0
     t._last_rx_ts = 0.0
     t.receiver_task = asyncio.create_task(zmq_receiver(t))
+    asyncio.create_task(_request_config_resend(t))
     await broadcast_tab(tab_id)
 
 

{better_rtplot-0.4.5 → better_rtplot-0.4.7}/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') {