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

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

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

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

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

{better_rtplot-0.4.7 → better_rtplot-0.4.9}/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):
@@ -538,6 +606,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.7 → better_rtplot-0.4.9}/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()
 
@@ -602,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
+            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.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.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):
@@ -750,6 +780,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)
@@ -1001,24 +1037,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):