Upload app.py

app.py

@@ -321,6 +321,16 @@ def find_flip_point(data, fit_params):
         return None
 
 
+def _plot_fingerprint(flip_reg, flip_ai, overlap):
+    """Create a hashable fingerprint of the plot's visual state.
+    The plot only changes when flip-point markers or overlap status change;
+    raw data and fit curves are constant for a given experiment."""
+    fr = (flip_reg['x'], flip_reg['y'], flip_reg['type']) if flip_reg else None
+    fa = (flip_ai['x'], flip_ai['y'], flip_ai['type']) if flip_ai else None
+    return (fr, fa, overlap)
+
+
+
 # ═════════════════════════════════════════════════════════════════════════
 # Consensus, Routing & State Machine
 # ═════════════════════════════════════════════════════════════════════════
@@ -497,6 +507,8 @@ def ingest_files(files):
 #  22:    exp_data
 #  23-28: flip_reg_info, flip_reg_tag, flip_ai_info, flip_ai_tag,
 #         flip_dual_col, flip_dual_state  (dual/diverging mode)
+#  29-30: flip_reg_sub, flip_ai_sub
+#  31:    plot_fp  (plot fingerprint state for skip optimization)
 
 def _empty_ws(msg=""):
     return (msg,
@@ -508,7 +520,8 @@ def _empty_ws(msg=""):
             "", None, gr.Column(visible=False), None,
             None,
             "", None, "", None, gr.Column(visible=False), None,
-            gr.Column(visible=True), gr.Column(visible=True))
+            gr.Column(visible=True), gr.Column(visible=True),
+            None)
 
 
 def fetch_next(username):
@@ -607,7 +620,8 @@ def fetch_next(username):
                 flip_reg_info, None, flip_ai_info, None,
                 gr.Column(visible=show_flip_dual), dual_state,
                 gr.Column(visible=show_flip_reg_sub),
-                gr.Column(visible=show_flip_ai_sub))
+                gr.Column(visible=show_flip_ai_sub),
+                None)
     except Exception as e:
         print(f"fetch_next render error: {e}\n{traceback.format_exc()}")
         return _empty_ws(f"❌ Render failed: {e}")
@@ -738,7 +752,7 @@ def reset_ratings():
 
 
 def update_workspace_state(data_val, fit_s_val, fit_reg_val, fit_ai_val,
-                           model_preds, overlap, exp_data):
+                           model_preds, overlap, exp_data, prev_fp):
     """Centralized state recalculation. Called when user changes any rating.
     Recomputes flip points, redraws plot, recalculates all visibility.
 
@@ -748,18 +762,22 @@ def update_workspace_state(data_val, fit_s_val, fit_reg_val, fit_ai_val,
       - None (cleared) or Borderline/Perfect → show sections
     Flip-point gating:
       - Uses effective quality (user > model) for computation
+    Plot optimization:
+      - Uses _plot_fingerprint to detect if the plot's visual state changed.
+      - Returns gr.skip() for the plot output when unchanged, saving bandwidth.
 
-    Outputs 15 items: (plot, fs_col, fd_col,
+    Outputs 16 items: (plot, fs_col, fd_col,
       flip_info, flip_tag, flip_col, flip_state,
       flip_reg_info, flip_reg_tag, flip_ai_info, flip_ai_tag,
       flip_dual_col, flip_dual_state,
-      flip_reg_sub, flip_ai_sub)
+      flip_reg_sub, flip_ai_sub, new_fp)
     """
     _empty = (None,
               gr.Column(visible=True), gr.Column(visible=False),
               "", None, gr.Column(visible=False), None,
               "", None, "", None, gr.Column(visible=False), None,
-              gr.Column(visible=True), gr.Column(visible=True))
+              gr.Column(visible=True), gr.Column(visible=True),
+              None)
     if exp_data is None:
         return _empty
 
@@ -803,9 +821,13 @@ def update_workspace_state(data_val, fit_s_val, fit_reg_val, fit_ai_val,
         if not overlap and ai_params and ai_fit_gate:
             flip_ai = find_flip_point(raw_data, ai_params)
 
-    # ── Redraw plot ──
-    fig = create_plot(raw_data, fname, reg_params, ai_params, overlap,
-                      flip_reg=flip_reg, flip_ai=flip_ai)
+    # ── Plot optimization: skip rebuild if visual state unchanged ──
+    new_fp = _plot_fingerprint(flip_reg, flip_ai, overlap)
+    if new_fp == prev_fp:
+        fig = gr.skip()
+    else:
+        fig = create_plot(raw_data, fname, reg_params, ai_params, overlap,
+                          flip_reg=flip_reg, flip_ai=flip_ai)
 
     # ── Section visibility ──
     show_fit_single = overlap and ui_show
@@ -851,7 +873,8 @@ def update_workspace_state(data_val, fit_s_val, fit_reg_val, fit_ai_val,
             gr.Column(visible=show_flip_dual),
             dual_state,
             gr.Column(visible=show_flip_reg_sub),
-            gr.Column(visible=show_flip_ai_sub))
+            gr.Column(visible=show_flip_ai_sub),
+            new_fp)
 
 
 # ═════════════════════════════════════════════════════���═══════════════════
@@ -1199,6 +1222,7 @@ def build_ui():
 
                 ws_exp_data = gr.State(None)
                 ws_flip_state = gr.State(None)
+                ws_plot_fp = gr.State(None)
 
                 ws_reset = gr.Button("🔄 Clear All Ratings", size="sm")
 
@@ -1270,29 +1294,29 @@ def build_ui():
                      ws_flip_tag, ws_flip_reg_tag, ws_flip_ai_tag]).then(
                     update_workspace_state,
                     [ws_dr, ws_fs, ws_fr, ws_fa,
-                     ws_preds, ws_overlap, ws_exp_data],
+                     ws_preds, ws_overlap, ws_exp_data, ws_plot_fp],
                     [ws_plot, ws_fs_col, ws_fd_col,
                      ws_flip_info, ws_flip_tag, ws_flip_col, ws_flip_state,
                      ws_flip_reg_info, ws_flip_reg_tag,
                      ws_flip_ai_info, ws_flip_ai_tag,
                      ws_flip_dual_col, ws_flip_dual_state,
-                     ws_flip_reg_sub, ws_flip_ai_sub])
+                     ws_flip_reg_sub, ws_flip_ai_sub, ws_plot_fp])
 
                 # Centralized state recalculation on any rating change
                 _state_inputs = [ws_dr, ws_fs, ws_fr, ws_fa,
-                                 ws_preds, ws_overlap, ws_exp_data]
+                                 ws_preds, ws_overlap, ws_exp_data, ws_plot_fp]
                 _state_outputs = [ws_plot, ws_fs_col, ws_fd_col,
                                   ws_flip_info, ws_flip_tag, ws_flip_col, ws_flip_state,
                                   ws_flip_reg_info, ws_flip_reg_tag,
                                   ws_flip_ai_info, ws_flip_ai_tag,
                                   ws_flip_dual_col, ws_flip_dual_state,
-                                  ws_flip_reg_sub, ws_flip_ai_sub]
+                                  ws_flip_reg_sub, ws_flip_ai_sub, ws_plot_fp]
                 ws_dr.input(update_workspace_state, _state_inputs, _state_outputs)
                 ws_fs.input(update_workspace_state, _state_inputs, _state_outputs)
                 ws_fr.input(update_workspace_state, _state_inputs, _state_outputs)
                 ws_fa.input(update_workspace_state, _state_inputs, _state_outputs)
 
-                # Output list — 31 components
+                # Output list — 32 components
                 ws_outs = [ws_status, ws_plot, ws_info, ws_ov_msg, ws_conf,
                            ws_fs_col, ws_fd_col,
                            ws_dr, ws_fs, ws_fr, ws_fa,
@@ -1303,7 +1327,8 @@ def build_ui():
                            ws_flip_reg_info, ws_flip_reg_tag,
                            ws_flip_ai_info, ws_flip_ai_tag,
                            ws_flip_dual_col, ws_flip_dual_state,
-                           ws_flip_reg_sub, ws_flip_ai_sub]
+                           ws_flip_reg_sub, ws_flip_ai_sub,
+                           ws_plot_fp]
 
                 ws_fetch.click(fetch_next, [ws_user], ws_outs)
                 ws_submit.click(submit_feedback,
@@ -1495,6 +1520,45 @@ def run_validation_tests():
     check("0-vote docs served last",
           sorted_docs[2]['num_votes'] == 0 and sorted_docs[3]['num_votes'] == 0)
 
+    # --- 8. Plot Fingerprint / gr.skip() Optimization ---
+    print("\n8. Plot Fingerprint Optimization (_plot_fingerprint)")
+    fp_a = _plot_fingerprint(None, None, True)
+    fp_b = _plot_fingerprint(None, None, True)
+    check("Same inputs → identical fingerprint", fp_a == fp_b)
+    fp_with_flip = _plot_fingerprint({'x': 0.25, 'y': 0.5, 'type': 'max'}, None, True)
+    check("Flip vs no-flip → different fingerprint", fp_with_flip != fp_a)
+    fp_overlap_t = _plot_fingerprint(None, None, True)
+    fp_overlap_f = _plot_fingerprint(None, None, False)
+    check("Overlap True vs False → different fingerprint", fp_overlap_t != fp_overlap_f)
+    # Verify update_workspace_state returns gr.skip() when fingerprint unchanged
+    mock_exp = {
+        'raw_data': {'measured_data': {'x_values': list(np.linspace(0, 1, 50)),
+                                       'y_values': list(np.sin(np.linspace(0, 1, 50)))}},
+        'reg_params': {'amplitude': 0.5, 'T': 1.0, 'phase': 0.0, 'offset': 0.0},
+        'ai_params': None, 'filename': 'test'
+    }
+    mock_mp = {'model_classes': {'data_quality': 2, 'regular_fit_quality': 2}}
+    # First call: prev_fp=None → must draw (not skip)
+    result1 = update_workspace_state('Perfect (2)', 'Perfect (2)', None, None,
+                                     mock_mp, True, mock_exp, None)
+    check("First call (prev_fp=None) → plot is NOT gr.skip()",
+          not isinstance(result1[0], type(gr.skip())))
+    new_fp = result1[-1]  # last element is the new fingerprint
+    check("First call returns a fingerprint tuple", isinstance(new_fp, tuple))
+    # Second call: same ratings → fingerprint unchanged → gr.skip()
+    result2 = update_workspace_state('Perfect (2)', 'Perfect (2)', None, None,
+                                     mock_mp, True, mock_exp, new_fp)
+    is_skip = (result2[0].__class__.__name__ == 'skip'
+               or result2[0] is gr.skip()  # Gradio skip sentinel
+               or repr(result2[0]) == repr(gr.skip()))
+    check("Second call (same ratings) → plot IS gr.skip()", is_skip)
+    # Third call: change rating to cross gate → fingerprint changes → redraw
+    result3 = update_workspace_state('Bad (0)', 'Perfect (2)', None, None,
+                                     mock_mp, True, mock_exp, new_fp)
+    check("Gate-crossing rating change → plot is NOT gr.skip()",
+          not isinstance(result3[0], type(gr.skip()))
+          or repr(result3[0]) != repr(gr.skip()))
+
     print(f"\n{'=' * 60}")
     print(f"RESULTS: {passed} passed, {failed} failed")
     print(f"{'=' * 60}")