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

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

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

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

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

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

@@ -414,8 +414,17 @@ def send_array(A, flags=0, copy=True, track=False):
     socket.send(A, flags, copy=copy, track=track)
 
 
-def initialize_plots(plot_descriptions=1):
-    """Send a json description of desired plot.
+def initialize_plots(plot_descriptions=1, handshake_timeout=2.0):
+    """Send a json description of desired plot and block until the
+    server acknowledges it.
+
+    Without the handshake, a fast script that calls ``initialize_plots()``
+    and immediately starts firing ``send_array()`` can lose the config
+    frame to ZMQ's PUB/SUB slow-joiner window — the server then drops
+    every subsequent data frame because no plot is declared yet and the
+    browser just stays blank. We resend the config on a short schedule
+    until the server PUSHes back a ``config_ack``, guaranteeing the
+    plot is live by the time this call returns.
 
     Inputs
     ------
@@ -426,6 +435,11 @@ def initialize_plots(plot_descriptions=1):
         - list of str: one plot, one trace per name
         - list of list of str: one plot per sublist
         - list of dict: multiple plots, each with full styling
+    handshake_timeout:
+        Max seconds to wait for the config_ack. On timeout we print a
+        warning and return (so an old server without the handshake
+        feature, or a server on a flaky network, doesn't block the
+        caller forever). Set to 0 to skip the handshake entirely.
     """
     global plot_desc_dict
 
@@ -477,11 +491,65 @@ def initialize_plots(plot_descriptions=1):
     else:
         raise TypeError("Incorrect usage of initialize_plots, verify github for usage")
 
-    #Send the category
-    socket.send_string(SENDING_PLOT_UPDATE)
+    _send_initialize_with_handshake(plot_desc_dict, handshake_timeout)
 
-    #Send the description
-    socket.send_json(plot_desc_dict)
+
+def _send_initialize_with_handshake(cfg, timeout):
+    """Publish ``cfg`` and block until the server acks it.
+
+    Any control events (button presses, slider updates) that happen to
+    arrive during the handshake are stashed in the module-level caches
+    so the next ``poll_controls()`` call still sees them — we don't
+    want the handshake to swallow real user interaction.
+    """
+    global _control_button_events
+
+    def _send_once():
+        socket.send_string(SENDING_PLOT_UPDATE)
+        socket.send_json(cfg)
+
+    _send_once()
+
+    if timeout is None or timeout <= 0:
+        return  # opt-out: fire-and-forget like the pre-handshake behavior
+
+    deadline = time.time() + timeout
+    resend_interval = 0.2
+    last_send = time.time()
+
+    poller = zmq.Poller()
+    poller.register(control_socket, zmq.POLLIN)
+
+    while time.time() < deadline:
+        remaining_ms = max(10, int((deadline - time.time()) * 1000))
+        next_resend_ms = max(1, int((last_send + resend_interval - time.time()) * 1000))
+        wait_ms = min(remaining_ms, next_resend_ms)
+        events = dict(poller.poll(wait_ms))
+        if control_socket in events:
+            try:
+                event = control_socket.recv_json(flags=zmq.NOBLOCK)
+            except (zmq.Again, zmq.ZMQError):
+                continue
+            evtype = event.get("type")
+            if evtype == "config_ack":
+                return
+            elif evtype == "button":
+                _control_button_events.append(event.get("id"))
+            elif evtype == "slider":
+                _control_slider_values[event.get("id")] = float(event.get("value", 0.0))
+            # Unknown / resend_config: ignore during handshake.
+        # Resend if the window elapsed without an ack; PUB/SUB will
+        # drop the first send during slow-join but retries land.
+        if time.time() - last_send >= resend_interval:
+            _send_once()
+            last_send = time.time()
+
+    print(
+        "rtplot.client: initialize_plots() timed out waiting for server ack"
+        f" after {timeout:.1f}s — the plot config may have been dropped."
+        " If you're on an older server (rtplot < 0.4.9) this warning is"
+        " expected and harmless."
+    )
 
 
 def set_display(display_id: str, value):

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

@@ -23,6 +23,8 @@ import asyncio
 import dataclasses
 import json
 import os
+import socket
+import subprocess
 import struct
 import sys
 import time
@@ -36,6 +38,7 @@ from typing import Optional
 import numpy as np
 import zmq
 import zmq.asyncio
+from zmq.utils.monitor import recv_monitor_message
 
 # pyzmq's asyncio integration needs event_loop.add_reader(), which the
 # Windows-default ProactorEventLoop (Python 3.8+) does not implement.
@@ -206,6 +209,7 @@ MSG_DELTA = 1
 
 ZMQ_DEFAULT_PORT = 5555
 ZMQ_CONTROL_PORT = ZMQ_DEFAULT_PORT + 1
+TCP_PROBE_TIMEOUT = 0.5
 
 RECEIVED_PLOT_UPDATE = 0
 RECEIVED_DATA = 1
@@ -262,6 +266,84 @@ def _control_target_from_data(ip):
     return f"{raw}:{ZMQ_CONTROL_PORT}"
 
 
+def _host_port_from_endpoint(endpoint, default_port=ZMQ_DEFAULT_PORT):
+    """Parse ``tcp://host:port`` or ``host[:port]`` into ``(host, port)``."""
+    raw = endpoint.strip()
+    if raw.startswith("tcp://"):
+        raw = raw[len("tcp://"):]
+    if raw.count(":") >= 1:
+        host, port_str = raw.rsplit(":", 1)
+    else:
+        host, port_str = raw, str(default_port)
+    try:
+        port = int(port_str)
+    except ValueError:
+        port = default_port
+    return host, port
+
+
+def _probe_tcp_endpoint(endpoint, timeout=TCP_PROBE_TIMEOUT):
+    """Return ``(open, reachable, error)`` for a TCP endpoint.
+
+    ``Connection refused`` still proves the host answered at the network
+    layer, so it is reachable even though that particular port is closed.
+    """
+    host, port = _host_port_from_endpoint(endpoint)
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            return True, True, None
+    except ConnectionRefusedError as exc:
+        return False, True, str(exc)
+    except OSError as exc:
+        return False, False, str(exc)
+
+
+def _ping_host(host):
+    """Best-effort host reachability fallback for firewalled TCP ports."""
+    if not host or host == "*":
+        return False
+    if sys.platform == "win32":
+        cmd = ["ping", "-n", "1", "-w", "700", host]
+    else:
+        cmd = ["ping", "-c", "1", "-W", "1", host]
+    try:
+        return subprocess.run(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=1.5,
+            check=False,
+        ).returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def _probe_connect_target(endpoint):
+    """Classify a connect-mode target for the browser status dot.
+
+    Returns ``(host_reachable, rtplot_ports_open, error)``. A reachable host
+    with closed rtplot ports is still a usable tab: ZeroMQ can connect now and
+    auto-complete the connection later when the sender starts listening.
+    """
+    host, data_port = _host_port_from_endpoint(endpoint)
+    data_open, data_reachable, data_err = _probe_tcp_endpoint(endpoint)
+    ctrl_endpoint = _control_target_from_data(endpoint)
+    ctrl_open, ctrl_reachable, ctrl_err = _probe_tcp_endpoint(
+        ctrl_endpoint, timeout=TCP_PROBE_TIMEOUT
+    )
+    host_reachable = data_reachable or ctrl_reachable
+    if not host_reachable and _ping_host(host):
+        host_reachable = True
+    if not host_reachable:
+        return (
+            False,
+            False,
+            f"{host} unreachable (data {data_port}: {data_err}; "
+            f"control {data_port + 1}: {ctrl_err})",
+        )
+    return True, bool(data_open and ctrl_open), None
+
+
 ###############################
 # Tab model #
 ###############################
@@ -274,7 +356,7 @@ class Tab:
     name: str
     mode: str                 # "bind" or "connect"
     endpoint: str             # user-visible label, e.g. "*:5555" or "pi1:5555"
-    status: str = "idle"      # idle | streaming | error
+    status: str = "idle"      # idle | connecting | connected | streaming | error
     error: Optional[str] = None
 
     # Plot state
@@ -302,6 +384,7 @@ class Tab:
     data_sock: Optional[zmq.Socket] = None
     ctrl_sock: Optional[zmq.Socket] = None
     receiver_task: Optional[asyncio.Task] = None
+    monitor_task: Optional[asyncio.Task] = None
 
     # Data buffer, lazy-allocated on first use (roughly 4 GB virtual,
     # but pages in only when written on Linux/Windows — a single tab
@@ -618,9 +701,38 @@ def _open_tab_sockets(tab: Tab):
     # Close any prior sockets first (e.g. on retry).
     _close_tab_sockets(tab)
 
+    connect_label = tab.endpoint
+    connect_data_ep = None
+    if tab.mode == "connect":
+        try:
+            connect_data_ep, connect_label = _normalize_connect_target(tab.endpoint)
+        except Exception as exc:  # noqa: BLE001
+            tab.status = "error"
+            tab.error = f"invalid endpoint: {exc}"
+            print(f"[{tab.id}] ZMQ open failed: {tab.error}")
+            return
+
+        tab.endpoint = connect_label
+        tab.status = "connecting"
+        tab.error = None
+        host_reachable, rtplot_ports_open, peer_err = _probe_connect_target(connect_label)
+        if not host_reachable:
+            tab.status = "error"
+            tab.error = peer_err
+            print(f"[{tab.id}] peer probe failed: {peer_err}")
+            return
+        if not rtplot_ports_open:
+            tab.status = "idle"
+            tab.error = None
+            print(
+                f"[{tab.id}] host reachable, rtplot ports closed;"
+                f" waiting for ZMQ peer: {connect_label}"
+            )
+
     last_exc: Exception | None = None
     attempts = 4 if tab.mode == "bind" else 1
     for attempt in range(attempts):
+        monitor = None
         try:
             data = zmq_ctx.socket(zmq.SUB)
             data.setsockopt_string(zmq.SUBSCRIBE, "")
@@ -635,14 +747,20 @@ def _open_tab_sockets(tab: Tab):
                 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)
+                monitor = data.get_monitor_socket(
+                    zmq.EVENT_CONNECTED
+                    | zmq.EVENT_DISCONNECTED
+                    | zmq.EVENT_CONNECT_DELAYED
+                    | zmq.EVENT_CONNECT_RETRIED
+                )
+                data.connect(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.endpoint = connect_label
+                tab.monitor_task = asyncio.create_task(zmq_monitor(tab, monitor))
+                print(f"[{tab.id}] ZMQ: connecting to {connect_data_ep} (ctrl {ctrl_ep})")
 
             tab.data_sock = data
             tab.ctrl_sock = ctrl
@@ -657,6 +775,11 @@ def _open_tab_sockets(tab: Tab):
             except Exception: pass
             try: ctrl.close(0)
             except Exception: pass
+            try:
+                if monitor is not None:
+                    monitor.close(0)
+            except Exception:
+                pass
             if attempt < attempts - 1:
                 wait = 0.15 * (attempt + 1)
                 print(
@@ -692,6 +815,62 @@ async def _cancel_task(task):
         pass
 
 
+async def zmq_monitor(tab: Tab, monitor_sock):
+    """Track transport-level ZMQ state for connect-mode tabs."""
+    try:
+        while True:
+            evt = await recv_monitor_message(monitor_sock)
+            event = evt.get("event")
+            if event == zmq.EVENT_CONNECTED:
+                if tab.status in ("connecting", "idle") and not tab.initialized:
+                    tab.status = "connected"
+                    tab.error = None
+                    await broadcast_tab(tab.id)
+            elif event == zmq.EVENT_DISCONNECTED:
+                if tab.mode == "connect":
+                    host_reachable, rtplot_ports_open, peer_err = _probe_connect_target(tab.endpoint)
+                    if host_reachable and not rtplot_ports_open:
+                        tab.status = "idle"
+                        tab.error = None
+                    elif host_reachable:
+                        tab.status = "idle"
+                        tab.error = None
+                    else:
+                        tab.status = "error"
+                        tab.error = peer_err
+                    await broadcast_tab(tab.id)
+            elif event == zmq.EVENT_CONNECT_RETRIED:
+                if tab.mode == "connect" and tab.status == "error":
+                    host_reachable, _rtplot_ports_open, peer_err = _probe_connect_target(tab.endpoint)
+                    if host_reachable:
+                        tab.status = "idle"
+                        tab.error = None
+                    else:
+                        tab.error = peer_err
+                    await broadcast_tab(tab.id)
+            elif event == zmq.EVENT_CONNECT_DELAYED:
+                if tab.mode == "connect" and tab.status == "error":
+                    host_reachable, _rtplot_ports_open, peer_err = _probe_connect_target(tab.endpoint)
+                    if host_reachable:
+                        tab.status = "idle"
+                        tab.error = None
+                    else:
+                        tab.error = peer_err
+                    await broadcast_tab(tab.id)
+    except asyncio.CancelledError:
+        raise
+    except Exception as exc:  # noqa: BLE001
+        if tab.mode == "connect" and tab.status != "streaming":
+            tab.status = "error"
+            tab.error = f"ZMQ monitor error: {exc}"
+            await broadcast_tab(tab.id)
+    finally:
+        try:
+            monitor_sock.close(0)
+        except Exception:  # noqa: BLE001
+            pass
+
+
 async def send_control_event(tab: Tab, event):
     """Forward a control event to the user's Python process, best-effort."""
     if tab.ctrl_sock is None:
@@ -780,6 +959,12 @@ async def zmq_receiver(tab: Tab):
             last_time = now
             tab.status = "streaming"
             tab.error = None
+            # Blocking-handshake ack: tells initialize_plots() on the
+            # client side that the config made it past PUB/SUB's
+            # slow-joiner window so it can stop resending and return.
+            # Old clients ignore unknown event types, so this is safe
+            # to emit unconditionally.
+            await send_control_event(tab, {"type": "config_ack"})
             await broadcast_text_tab(tab.id, tab.config_message)
             await broadcast_tab(tab.id)
             snap = make_snapshot_message(tab)
@@ -997,6 +1182,7 @@ async def delete_tab(tab_id: str):
     if t is None:
         return
     await _cancel_task(t.receiver_task)
+    await _cancel_task(t.monitor_task)
     _close_tab_sockets(t)
     # Move any viewers off this tab back to bind_me on the browser side;
     # server tells them via tab_removed + they re-subscribe.
@@ -1085,6 +1271,8 @@ async def reconnect_tab(tab_id: str):
     if t is None:
         return
     await _cancel_task(t.receiver_task)
+    await _cancel_task(t.monitor_task)
+    t.monitor_task = None
     # _open_tab_sockets closes first, then reopens. Status gets set to
     # "idle" on success or "error" + a message on bind/connect failure.
     _open_tab_sockets(t)
@@ -1461,6 +1649,7 @@ async def on_cleanup(app):
         await _cancel_task(app.get(key))
     for t in list(tabs.values()):
         await _cancel_task(t.receiver_task)
+        await _cancel_task(t.monitor_task)
         _close_tab_sockets(t)
     for ws in list(ws_clients):
         try:

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

@@ -15,6 +15,7 @@
   .tab.active { background: #fff; color: #111; border-color: #bbb; font-weight: 600; }
   .tab .tab-dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: #bbb; flex: 0 0 auto; }
   .tab .tab-dot.idle { background: #bbb; }
+  .tab .tab-dot.connected { background: #e8b13a; box-shadow: 0 0 3px rgba(232,177,58,0.5); }
   .tab .tab-dot.streaming { background: #2ebf4e; box-shadow: 0 0 3px rgba(46,191,78,0.5); }
   .tab .tab-dot.error { background: #e05252; }
   .tab .tab-dot.connecting { background: #e8b13a; animation: pulse 1s ease-in-out infinite alternate; }
@@ -987,6 +988,19 @@
       }
 
       // ---- Tab bar rendering ----
+      function tabStatusTitle(t) {
+        if (t.error) return t.error;
+        if (t.status === 'streaming') return 'Receiving rtplot data';
+        if (t.status === 'connected') return 'ZMQ connected; waiting for plot config/data';
+        if (t.status === 'connecting') return 'Checking device connection';
+        if (t.status === 'idle') {
+          return t.mode === 'bind'
+            ? 'Listening for a sender'
+            : 'Host reachable; rtplot ports are not connected';
+        }
+        return 'Status unknown';
+      }
+
       function renderTabs() {
         tabbar.innerHTML = '';
         // Stable order: bind_me first, then others in insertion order.
@@ -1002,7 +1016,7 @@
 
           const dot = document.createElement('span');
           dot.className = 'tab-dot ' + (t.status || 'idle');
-          if (t.error) dot.title = t.error;
+          dot.title = tabStatusTitle(t);
           el.appendChild(dot);
 
           // Stacked labels: name on top, endpoint on a muted subline so