Update app.py

app.py

@@ -6,7 +6,7 @@ import librosa
 import matplotlib.pyplot as plt
 
 from dataclasses import dataclass
-from typing import Dict, Any, Tuple, List
+from typing import Dict, Any, Tuple, List, Optional
 
 # =========================================================
 # Config
@@ -15,19 +15,6 @@ TARGET_SR = 16000
 APP_DIR = os.path.dirname(os.path.abspath(__file__))
 
 
-# =========================================================
-# Bundled audio (repo root / same folder as app.py)
-# =========================================================
-def list_bundled_audio() -> List[str]:
-    exts = (".mp3", ".wav", ".m4a", ".flac", ".ogg")
-    try:
-        files = [fn for fn in os.listdir(APP_DIR) if fn.lower().endswith(exts)]
-    except Exception:
-        files = []
-    files.sort()
-    return files
-
-
 # =========================================================
 # Helpers
 # =========================================================
@@ -46,6 +33,29 @@ def safe_pct(x: float) -> str:
     return f"{x*100:.1f}%"
 
 
+def list_bundled_audio() -> List[str]:
+    exts = (".mp3", ".wav", ".m4a", ".flac", ".ogg")
+    try:
+        items = os.listdir(APP_DIR)
+    except Exception:
+        return []
+    files = [fn for fn in items if fn.lower().endswith(exts)]
+    files.sort()
+    return files
+
+
+def load_audio_file(path: str) -> Tuple[np.ndarray, int]:
+    """
+    Robust loader for both uploads and bundled files.
+    Returns mono float32 waveform and sample rate.
+    """
+    y, sr = librosa.load(path, sr=None, mono=True)
+    if y is None or len(y) == 0:
+        return np.array([], dtype=np.float32), int(sr) if sr else TARGET_SR
+    y = y.astype(np.float32)
+    return y, int(sr)
+
+
 # =========================================================
 # Features
 # =========================================================
@@ -64,10 +74,6 @@ class Features:
 
 
 def compute_features(y: np.ndarray, sr: int) -> Tuple[Features, Dict[str, Any]]:
-    """
-    Explainable acoustic features + artifacts for plotting.
-    (No medical claims; only measurable signals.)
-    """
     if y is None or len(y) == 0:
         f = Features(
             duration_s=float("nan"),
@@ -81,7 +87,7 @@ def compute_features(y: np.ndarray, sr: int) -> Tuple[Features, Dict[str, Any]]:
             pause_total_s=0.0,
             active_ratio=float("nan"),
         )
-        return f, {"y": np.array([]), "sr": sr}
+        return f, {"y": np.array([]), "sr": sr, "hop": 160, "pauses": [], "pitch": np.array([]), "times": np.array([])}
 
     # Resample to stable SR
     if sr != TARGET_SR:
@@ -90,14 +96,14 @@ def compute_features(y: np.ndarray, sr: int) -> Tuple[Features, Dict[str, Any]]:
     else:
         y = y.astype(np.float32)
 
-    # Normalize [-1, 1] for stable plots/features
+    # Normalize [-1, 1]
     mx = float(np.max(np.abs(y))) + 1e-9
     y = y / mx
 
     duration = float(len(y) / sr)
 
-    hop = 160   # 10ms @ 16k
-    frame = 400 # 25ms @ 16k
+    hop = 160
+    frame = 400
 
     rms = librosa.feature.rms(y=y, frame_length=frame, hop_length=hop)[0]
     zcr = librosa.feature.zero_crossing_rate(y, frame_length=frame, hop_length=hop)[0]
@@ -106,7 +112,7 @@ def compute_features(y: np.ndarray, sr: int) -> Tuple[Features, Dict[str, Any]]:
     rms_std = float(np.std(rms)) if rms.size else float("nan")
     zcr_mean = float(np.mean(zcr)) if zcr.size else float("nan")
 
-    # Pitch via pyin (can fail on noise/short clips)
+    # Pitch via pyin
     try:
         f0, _, _ = librosa.pyin(
             y,
@@ -139,12 +145,10 @@ def compute_features(y: np.ndarray, sr: int) -> Tuple[Features, Dict[str, Any]]:
             pitch_median = float("nan")
             pitch_iqr = float("nan")
 
-    # Pause detection: low-RMS frames as silence
+    # Pause detection
     if rms.size:
         thr = float(np.percentile(rms, 20)) * 0.8
         silent = rms < thr
-
-        # pauses >= 0.2s
         min_pause_frames = int(0.2 / (hop / sr))
 
         pauses = []
@@ -166,7 +170,6 @@ def compute_features(y: np.ndarray, sr: int) -> Tuple[Features, Dict[str, Any]]:
         pause_total_s = float(sum((e - s) * (hop / sr) for s, e in pauses))
         active_ratio = float(1.0 - np.mean(silent))
     else:
-        thr = None
         pauses = []
         n_pauses = 0
         pause_total_s = 0.0
@@ -189,13 +192,11 @@ def compute_features(y: np.ndarray, sr: int) -> Tuple[Features, Dict[str, Any]]:
         "y": y,
         "sr": sr,
         "hop": hop,
-        "frame": frame,
         "rms": rms,
         "zcr": zcr,
-        "times": times,
         "pitch": pitch,
+        "times": times,
         "pauses": pauses,
-        "rms_thr": thr,
     }
     return feats, artifacts
 
@@ -216,9 +217,7 @@ def plot_waveform_with_pauses(art: Dict[str, Any]) -> plt.Figure:
         t = np.arange(len(y)) / sr
         ax.plot(t, y, linewidth=0.8)
         for (s, e) in pauses:
-            ts = s * (hop / sr)
-            te = e * (hop / sr)
-            ax.axvspan(ts, te, alpha=0.2)
+            ax.axvspan(s * (hop / sr), e * (hop / sr), alpha=0.2)
         ax.set_title("Waveform (with detected pauses)")
         ax.set_xlabel("Time (s)")
         ax.set_ylabel("Amplitude")
@@ -250,9 +249,6 @@ def plot_pitch(art: Dict[str, Any]) -> plt.Figure:
     return fig
 
 
-# =========================================================
-# UI formatting
-# =========================================================
 def features_table(feats: Features) -> List[List[str]]:
     def f3(x):
         return "—" if (x is None or not math.isfinite(x)) else f"{float(x):.3f}"
@@ -285,57 +281,44 @@ def explain_text_single(feats: Features) -> str:
         "This is an **explainability demo**: it shows **measurable speech signals** (not *why* they change).\n\n"
         + "\n".join(bullets)
         + "\n\n"
-        "**Important:** this is **not a diagnosis** and **not a medical device**. "
-        "Use it as an **educational visualization** or a conversation starter."
+        "**Important:** this is **not a diagnosis** and **not a medical device**."
     )
 
 
 def explain_text_timeline() -> str:
     return (
         "### Timeline: how to use this\n"
-        "- Upload or select **multiple recordings of the same person** (e.g., different days/weeks).\n"
-        "- The key principle is **within-person change over time** relative to the person’s own baseline.\n"
-        "- We show **signals** (pauses, pitch, energy), not a clinical label.\n\n"
-        "**Tip:** select/upload files in **chronological order** (old → new) to make the trend meaningful."
+        "- Use **multiple recordings of the same person** (e.g., days/weeks).\n"
+        "- The key principle is **within-person change over time** relative to baseline.\n"
+        "- We show **signals** (pauses, pitch, energy), not a clinical label.\n"
     )
 
 
 # =========================================================
 # Callbacks
 # =========================================================
-def analyze_one(audio: Tuple[int, np.ndarray]):
-    if audio is None:
+def analyze_one(audio_path: Optional[str]):
+    # audio_path comes from gr.Audio(type="filepath")
+    if not audio_path:
         return [], None, None, "### Upload or record audio to start."
 
-    sr, y = audio
+    y, sr = load_audio_file(audio_path)
     feats, art = compute_features(y, sr)
-    table = features_table(feats)
-    wf = plot_waveform_with_pauses(art)
-    pc = plot_pitch(art)
-    expl = explain_text_single(feats)
 
-    return table, wf, pc, expl
+    return features_table(feats), plot_waveform_with_pauses(art), plot_pitch(art), explain_text_single(feats)
 
 
-def analyze_many(files):
-    """
-    Analyze multiple audio files (same person over time).
-    `files` are Gradio file objects (each has .name) OR objects with a .name path.
-    """
-    if not files or len(files) < 2:
+def analyze_many_filepaths(paths: List[str]):
+    if not paths or len(paths) < 2:
         rows = [[1, "—", "Upload at least 2 audio files to see a trend.", "", "", "", "", ""]]
         return rows, None, "### Upload at least 2 recordings."
 
     rows = []
-    pause_series = []
-    pitch_series = []
-    rms_series = []
+    pause_series, pitch_series, rms_series = [], [], []
 
-    for idx, f in enumerate(files, start=1):
-        path = getattr(f, "name", None) or str(f)
+    for idx, path in enumerate(paths, start=1):
         name = os.path.basename(path)
-
-        y, sr = librosa.load(path, sr=None, mono=True)
+        y, sr = load_audio_file(path)
         feats, _ = compute_features(y, sr)
 
         pause_s = feats.pause_total_s if math.isfinite(feats.pause_total_s) else np.nan
@@ -361,11 +344,9 @@ def analyze_many(files):
     fig = plt.figure(figsize=(10, 3.4))
     ax = fig.add_subplot(111)
     x = np.arange(1, len(rows) + 1)
-
     ax.plot(x, pause_series, marker="o", linewidth=1.2, label="Total pause time (s)")
     ax.plot(x, pitch_series, marker="o", linewidth=1.2, label="Median pitch (Hz)")
     ax.plot(x, rms_series, marker="o", linewidth=1.2, label="RMS mean")
-
     ax.set_title("Trend across recordings (same person: baseline → change)")
     ax.set_xlabel("Recording # (order)")
     ax.set_ylabel("Value (different scales)")
@@ -375,42 +356,66 @@ def analyze_many(files):
     return rows, fig, explain_text_timeline()
 
 
+def analyze_many_uploaded(files):
+    # gr.Files gives file objects; map to filepaths
+    if not files:
+        return analyze_many_filepaths([])
+    paths = []
+    for f in files:
+        p = getattr(f, "name", None) or str(f)
+        paths.append(p)
+    return analyze_many_filepaths(paths)
+
+
 def analyze_many_bundled(selected_filenames: List[str]):
-    """
-    Analyze files that are bundled with the Space (repo root / app directory).
-    """
-    if not selected_filenames or len(selected_filenames) < 2:
-        rows = [[1, "—", "Select at least 2 bundled files.", "", "", "", "", ""]]
-        return rows, None, "### Select at least 2 bundled recordings."
+    if not selected_filenames:
+        return analyze_many_filepaths([])
+    paths = [os.path.join(APP_DIR, fn) for fn in selected_filenames]
+    return analyze_many_filepaths(paths)
 
-    class _F:
-        def __init__(self, name: str):
-            self.name = name
 
-    files = [_F(os.path.join(APP_DIR, fn)) for fn in selected_filenames]
-    return analyze_many(files)
+def refresh_bundled_choices():
+    bundled = list_bundled_audio()
+    diag = diagnostics_text(bundled)
+    return gr.CheckboxGroup(choices=bundled, value=[]), diag
+
+
+def diagnostics_text(bundled: List[str]) -> str:
+    lines = []
+    lines.append(f"**APP_DIR:** `{APP_DIR}`")
+    lines.append(f"**CWD:** `{os.getcwd()}`")
+    lines.append(f"**Found bundled audio files:** {len(bundled)}")
+    if bundled:
+        for fn in bundled:
+            full = os.path.join(APP_DIR, fn)
+            try:
+                size = os.path.getsize(full)
+                lines.append(f"- `{fn}` ({size} bytes)")
+            except Exception:
+                lines.append(f"- `{fn}` (size unknown)")
+    else:
+        lines.append("- *(none found)*")
+    lines.append("")
+    lines.append("**Microphone note:** recording can be blocked by browser/iframe policies.")
+    lines.append("Try opening the Space in a new tab and allow microphone permissions.")
+    return "\n".join(lines)
 
 
 # =========================================================
-# UI (polished + readable cards)
+# UI (readable cards + tabs + diagnostics)
 # =========================================================
 CSS = """
 :root{
   --bg: #0b0f19;
-  --text: rgba(255,255,255,0.92);
   --shadow: 0 12px 30px rgba(0,0,0,0.35);
 }
-
 .gradio-container{
   background:
     radial-gradient(1200px 700px at 10% 10%, rgba(124,58,237,0.25), transparent 55%),
     radial-gradient(900px 600px at 90% 20%, rgba(34,197,94,0.18), transparent 55%),
     radial-gradient(1100px 800px at 40% 100%, rgba(59,130,246,0.15), transparent 60%),
     var(--bg) !important;
-  color: var(--text) !important;
 }
-
-/* Header: force readable (light background + dark text) */
 #header{
   background: rgba(255,255,255,0.92) !important;
   color: #0b0f19 !important;
@@ -420,35 +425,17 @@ CSS = """
   box-shadow: var(--shadow);
 }
 #header *{ color: #0b0f19 !important; }
-
-#title{
-  font-size: 28px;
-  font-weight: 780;
-  letter-spacing: -0.02em;
-  margin: 0;
-}
-#subtitle{
-  margin-top: 8px;
-  color: rgba(0,0,0,0.72) !important;
-  font-size: 14px;
-  line-height: 1.45;
-}
+#title{ font-size: 28px; font-weight: 780; margin: 0; letter-spacing: -0.02em; }
+#subtitle{ margin-top: 8px; color: rgba(0,0,0,0.72) !important; font-size: 14px; line-height: 1.45; }
 .badge{
-  display: inline-flex;
-  align-items: center;
-  gap: 8px;
-  padding: 6px 10px;
-  border-radius: 999px;
+  display: inline-flex; align-items: center; gap: 8px;
+  padding: 6px 10px; border-radius: 999px;
   border: 1px solid rgba(0,0,0,0.12);
   background: rgba(0,0,0,0.04);
   color: rgba(0,0,0,0.72) !important;
-  font-size: 12px;
-  margin-right: 10px;
-  margin-bottom: 8px;
+  font-size: 12px; margin-right: 10px; margin-bottom: 8px;
 }
 .badge b{ color: #0b0f19 !important; font-weight: 720; }
-
-/* Explanation blocks: force readable (light card) */
 .card{
   background: rgba(255,255,255,0.92) !important;
   color: #0b0f19 !important;
@@ -463,6 +450,7 @@ CSS = """
 
 def build_ui():
     bundled = list_bundled_audio()
+    diag0 = diagnostics_text(bundled)
 
     with gr.Blocks(
         css=CSS,
@@ -477,10 +465,10 @@ def build_ui():
               <div id="subtitle">
                 <span class="badge"><b>Goal</b> show measurable speech signals</span>
                 <span class="badge"><b>No diagnosis</b> not a medical device</span>
-                <span class="badge"><b>Anti–black box</b> we show signals, not labels</span>
+                <span class="badge"><b>Anti–black box</b> show signals, not labels</span>
                 <p style="margin-top:10px">
-                  Use “Timeline” to demonstrate the key principle: <b>within-person change over time</b>.
-                  Your bundled files (e.g. <code>sample_a.mp3</code>, <code>sample_b.mp3</code>) can be selected below.
+                  If you committed <code>sample_a.mp3</code> and <code>sample_b.mp3</code> to the repo root,
+                  they should appear under “Bundled samples”. Use “Diagnostics” to verify what the container sees.
                 </p>
               </div>
             </div>
@@ -491,25 +479,13 @@ def build_ui():
             with gr.TabItem("Single recording"):
                 with gr.Row():
                     with gr.Column(scale=5):
-                        audio = gr.Audio(label="Audio", sources=["upload", "microphone"], type="numpy")
+                        # filepath is more robust on Spaces for uploads + mic
+                        audio = gr.Audio(label="Audio", sources=["upload", "microphone"], type="filepath")
                         run = gr.Button("Analyze", variant="primary")
-                        with gr.Accordion("What happens technically?", open=False):
-                            gr.Markdown(
-                                """
-                                - Extract **acoustic features** (RMS energy, ZCR), estimate **pitch** with *pyin*,
-                                  and detect **pauses** using an adaptive energy threshold.
-                                - Output is **explainable by design**: we show the measured signals.
-                                """
-                            )
+                        gr.Markdown("Tip: if microphone doesn’t work, try upload first. Then check Diagnostics.", elem_classes=["card"])
 
                     with gr.Column(scale=7):
-                        feats_df = gr.Dataframe(
-                            headers=["Feature", "Value"],
-                            datatype=["str", "str"],
-                            interactive=False,
-                            wrap=True,
-                            label="Measurable features",
-                        )
+                        feats_df = gr.Dataframe(headers=["Feature", "Value"], interactive=False, wrap=True, label="Measurable features")
                         wf_plot = gr.Plot(label="Waveform + pauses")
                         pitch_plot = gr.Plot(label="Pitch")
                         explanation = gr.Markdown("### Upload or record audio to start.", elem_classes=["card"])
@@ -520,30 +496,20 @@ def build_ui():
                 with gr.Row():
                     with gr.Column(scale=5):
                         gr.Markdown("#### Option A — Upload from your computer")
-                        files = gr.Files(
-                            label="Upload multiple audio files (same person)",
-                            file_count="multiple",
-                            file_types=["audio"],
-                        )
+                        files = gr.Files(label="Upload multiple audio files (same person)", file_count="multiple", file_types=["audio"])
                         run_many = gr.Button("Analyze uploaded timeline", variant="primary")
 
-                        gr.Markdown("#### Option B — Select bundled samples (from repo root)")
-                        if bundled:
-                            bundled_select = gr.CheckboxGroup(
-                                choices=bundled,
-                                label="Bundled audio files",
-                            )
+                        gr.Markdown("#### Option B — Bundled samples (from repo root)")
+                        bundled_select = gr.CheckboxGroup(choices=bundled, label="Bundled audio files")
+                        with gr.Row():
+                            refresh_btn = gr.Button("Refresh bundled list", variant="secondary")
                             run_bundled = gr.Button("Analyze selected bundled samples", variant="secondary")
-                            gr.Markdown("Tip: select/upload in **chronological order** (old → new). MP3 is fine.")
-                        else:
-                            bundled_select = gr.CheckboxGroup(choices=[], label="Bundled audio files")
-                            run_bundled = gr.Button("No bundled audio found", variant="secondary", interactive=False)
-                            gr.Markdown("No bundled audio files were found next to app.py.")
+
+                        gr.Markdown("Select/upload at least **2** recordings. MP3 is fine.", elem_classes=["card"])
 
                     with gr.Column(scale=7):
                         timeline_df = gr.Dataframe(
                             headers=["#", "File", "Duration", "Pauses", "Pause(s)", "Pitch(Hz)", "RMS", "Active %"],
-                            datatype=["number", "str", "str", "number", "str", "str", "str", "str"],
                             interactive=False,
                             wrap=True,
                             label="Per-file overview",
@@ -551,20 +517,27 @@ def build_ui():
                         timeline_plot = gr.Plot(label="Trend plot")
                         timeline_expl = gr.Markdown("### Upload or select at least 2 recordings.", elem_classes=["card"])
 
-                run_many.click(analyze_many, inputs=[files], outputs=[timeline_df, timeline_plot, timeline_expl])
-                run_bundled.click(
-                    analyze_many_bundled,
-                    inputs=[bundled_select],
-                    outputs=[timeline_df, timeline_plot, timeline_expl],
-                )
+                run_many.click(analyze_many_uploaded, inputs=[files], outputs=[timeline_df, timeline_plot, timeline_expl])
+                run_bundled.click(analyze_many_bundled, inputs=[bundled_select], outputs=[timeline_df, timeline_plot, timeline_expl])
+                refresh_btn.click(refresh_bundled_choices, inputs=None, outputs=[bundled_select, gr.Markdown(value=diag0)])
+
+            with gr.TabItem("Diagnostics"):
+                diag = gr.Markdown(diag0, elem_classes=["card"])
+                diag_refresh = gr.Button("Refresh diagnostics", variant="secondary")
+
+                def _refresh_diag():
+                    b = list_bundled_audio()
+                    return diagnostics_text(b)
+
+                diag_refresh.click(_refresh_diag, inputs=None, outputs=[diag])
 
         with gr.Accordion("Ethics & transparency", open=False):
             gr.Markdown(
                 """
                 - This demo makes **no clinical claim** and provides **no diagnosis**.
                 - Output is intended as **observable signals** to support discussion and understanding.
-                - In care settings, interpretation must always include **context + conversation + clinical judgment**.
-                """
+                """,
+                elem_classes=["card"],
             )
 
     return demo
@@ -574,6 +547,6 @@ if __name__ == "__main__":
     demo = build_ui()
     demo.queue(max_size=32)
 
-    # HF Spaces-proof: use platform-provided port (avoids "Cannot find empty port 7860")
+    # HF Spaces-proof port binding
     port = int(os.environ.get("PORT", os.environ.get("GRADIO_SERVER_PORT", "7860")))
     demo.launch(server_name="0.0.0.0", server_port=port)