Update app.py

src/app.py

@@ -203,6 +203,11 @@ INTERPRETATION_TEXT = """
     - Not sure of the domain? Switch **Domain of the text** to *Soft Estimate* or *Estimate* — the estimation is conducted by a pretrained transformer-based classifier that infers it automatically.
 """
 
+DETECTING_HTML = (
+    '<div class="spinner"></div>'
+    '<span>Detecting… this can take a few seconds.</span>'
+)
+
 FOOTER_TEXT = (
     "This tool is developed for research purposes only. The detection results are not "
     "100% accurate and should not be used as the sole basis for any critical decisions. "
@@ -249,35 +254,46 @@ def on_domain_mode_change(domain_mode: str):
     )
 
 
-def run_detection(text: str, domain_mode: str, manual_domain: str, alpha: float, progress=gr.Progress()):
+DETECT_BTN_IDLE = gr.update(value="🔍 Detect", interactive=True)
+DETECT_BTN_BUSY = gr.update(value="⏳ Detecting…", interactive=False)
+
+
+def run_detection(text: str, domain_mode: str, manual_domain: str, alpha: float):
     """Detect button handler: runs inference and refreshes all result widgets.
 
-    `progress` is a `gr.Progress` instance (see
-    https://www.gradio.app/guides/progress-bars) -- Gradio recognizes it by
-    its default value and doesn't treat it as a regular input, so it's left
-    out of `detect_btn.click(inputs=...)`. The actual scoring pass
-    (`_run_inference`) is one blocking call with no internal hooks to report
-    from, so the bar advances in stages around it rather than continuously.
+    Written as a generator (`yield` instead of `return`) so it can push the
+    UI to the frontend in two steps instead of one:
+
+    1. The instant the button is pressed — flip on the spinner + "Detecting…"
+       button state, before any inference has run.
+    2. Once `_run_inference` returns (or raises) — turn the spinner back off
+       and show the result (or let the error surface via `gr.Error`).
+
+    That before/after pair is what makes it unambiguous whether detection is
+    still running, unlike the old staged `gr.Progress()` bar, which jumped
+    between a few fixed percentages and didn't clearly resolve to "done".
     """
+    # Everything except the spinner + button is left untouched on this first
+    # yield — any previous result stays on screen until the new one is ready.
+    unchanged_results = (gr.update(),) * 7
+    yield unchanged_results + (gr.update(visible=True), DETECT_BTN_BUSY)
+
     if not text or not text.strip():
+        yield unchanged_results + (gr.update(visible=False), DETECT_BTN_IDLE)
         raise gr.Error("⚠️ Please enter some text before detecting.")
 
-    progress(0, desc="Validating input…")
     domain = resolve_domain_selection(domain_mode, manual_domain)
-    is_auto_domain = domain in (ESTIMATE_DOMAIN, SOFTEST_DOMAIN)
 
     start_time = time.time()
     try:
-        progress(0.2, desc="Estimating domain…" if is_auto_domain else "Tokenizing text…")
-        progress(0.4, desc="Scoring text against the reference model…")
         crit, p_value = _run_inference(text, domain)
-        progress(0.9, desc="Computing p-value…")
     except gr.Error:
+        yield unchanged_results + (gr.update(visible=False), DETECT_BTN_IDLE)
         raise
     except Exception as e:  # noqa: BLE001 — surfaced to the user via gr.Error
+        yield unchanged_results + (gr.update(visible=False), DETECT_BTN_IDLE)
         raise gr.Error(f"Detection failed: {e}")
     elapsed_time = time.time() - start_time
-    progress(1.0, desc="Done")
 
     stats_manager.increment_detection()
 
@@ -290,7 +306,7 @@ def run_detection(text: str, domain_mode: str, manual_domain: str, alpha: float,
         "feedback_given": False,
     }
 
-    return (
+    yield (
         gr.update(value=format_conclusion(p_value, alpha), visible=True),
         gr.update(visible=True),  # interpretation accordion
         gr.update(value=f"⏱️ Processing time: {elapsed_time:.2f} seconds", visible=True),
@@ -298,6 +314,8 @@ def run_detection(text: str, domain_mode: str, manual_domain: str, alpha: float,
         gr.update(visible=True),  # feedback buttons row (re-shown in case a prior run hid it)
         gr.update(visible=False),  # feedback thanks message
         detection_state,
+        gr.update(visible=False),  # detecting indicator — inference is done
+        DETECT_BTN_IDLE,
     )
 
 
@@ -355,6 +373,27 @@ CUSTOM_CSS = """
 #detect-btn:hover {
     background-color: #fd8d3c !important;
 }
+#detecting-indicator {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin: -0.3rem 0 0.5rem;
+    color: #b45309;
+    font-size: 0.92rem;
+    font-weight: 500;
+}
+#detecting-indicator .spinner {
+    flex: none;
+    width: 1rem;
+    height: 1rem;
+    border: 2.5px solid #fde3c8;
+    border-top-color: #fd8d3c;
+    border-radius: 50%;
+    animation: detecting-spin 0.7s linear infinite;
+}
+@keyframes detecting-spin {
+    to { transform: rotate(360deg); }
+}
 .conclusion-card {
     background-color: #f8fafc;
     border: 1px solid #e5e7eb;
@@ -451,6 +490,13 @@ def build_interface() -> gr.Blocks:
                 label="Significance level (α)", scale=1,
             )
 
+        # Hidden by default; `run_detection` toggles it on for the duration of
+        # each detection run so there's an unmistakable, animated "still
+        # running" cue right under the button the user just pressed.
+        detecting_indicator = gr.HTML(
+            DETECTING_HTML, visible=False, elem_id="detecting-indicator",
+        )
+
         domain_mode_info = gr.Markdown(DOMAIN_MODE_INFO[DEFAULT_DOMAIN_MODE])
         if not DOMAIN_ESTIMATOR_AVAILABLE:
             gr.Markdown(
@@ -493,7 +539,13 @@ def build_interface() -> gr.Blocks:
             outputs=[
                 conclusion_md, interpretation_box, elapsed_caption,
                 feedback_section, feedback_row, feedback_thanks, detection_state,
+                detecting_indicator, detect_btn,
             ],
+            # We drive the "still running" indicator ourselves (spinner +
+            # busy button label, both toggled by `run_detection`'s two
+            # yields), so suppress Gradio's own progress overlay to avoid
+            # showing two different busy indicators at once.
+            show_progress="hidden",
         )
 
         expected_btn.click(