feat: add background threads for transcription and show statuses concurrently

app.py

@@ -40,10 +40,72 @@ def get_initial_state():
         "questions_html": format_questions_html([]),
         "log_html": format_activity_log([]),
         "speaker_name": "",
-        "generation_in_progress": False  # Track if background generation is running
+        "generation_in_progress": False,  # Track if background generation is running
+        "transcription_in_progress": False  # Track if background transcription is running
     }
 
 
+def transcribe_audio_background(audio_data: np.ndarray, sample_rate: int, state: dict):
+    """
+    Transcribe audio in background thread.
+    Updates state dict directly (shared reference).
+    After transcription, may trigger question generation.
+    """
+    try:
+        import wave
+
+        # Save to temp file for Whisper
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+            with wave.open(f.name, 'wb') as wav:
+                wav.setnchannels(1)
+                wav.setsampwidth(2)
+                wav.setframerate(sample_rate)
+                wav.writeframes((audio_data * 32767).astype(np.int16).tobytes())
+            temp_path = f.name
+
+        # Transcribe
+        new_text = transcribe_audio(temp_path)
+        os.unlink(temp_path)
+
+        if new_text.strip():
+            ctx = state["context"]
+            ctx.add_transcript(new_text)
+            state["transcript"] = ctx.get_full_transcript()
+
+            current_word_count = len(state["transcript"].split())
+            words_since_last = current_word_count - state.get("last_word_count", 0)
+
+            # Add transcription to activity log
+            state["activity_log"].append({"type": "transcribe", "words": current_word_count})
+            state["log_html"] = format_activity_log(state["activity_log"])
+
+            # Check if we should generate questions (and not already generating)
+            should_generate = (
+                current_word_count >= MIN_WORDS_FOR_QUESTIONS and
+                current_word_count < MAX_WORDS_CAP and
+                words_since_last >= WORDS_BETWEEN_GENERATIONS and
+                not state.get("generation_in_progress", False)
+            )
+
+            if should_generate:
+                state["last_word_count"] = current_word_count
+                state["generation_in_progress"] = True
+
+                # Start question generation in another thread
+                thread = threading.Thread(
+                    target=generate_questions_background,
+                    args=(state,),
+                    daemon=True
+                )
+                thread.start()
+
+    except Exception as e:
+        state["activity_log"].append({"type": "error", "msg": f"Transcription error: {str(e)}"})
+        state["log_html"] = format_activity_log(state["activity_log"])
+    finally:
+        state["transcription_in_progress"] = False
+
+
 def generate_questions_background(state: dict):
     """
     Generate questions in background thread.
@@ -103,7 +165,6 @@ def process_streaming_audio(
     if "context" not in state:
         state = get_initial_state()
 
-    ctx = state["context"]
     activity_log = state.get("activity_log", [])
 
     # Convert to float32 if needed
@@ -122,11 +183,36 @@ def process_streaming_audio(
     # Accumulate audio
     state["audio_buffer"] = np.concatenate([state.get("audio_buffer", np.array([], dtype=np.float32)), audio_data])
 
-    # Check if we have enough audio to process (CHUNK_DURATION seconds)
+    # Calculate status info
     samples_needed = sample_rate * CHUNK_DURATION
-    if len(state["audio_buffer"]) < samples_needed:
-        word_count = len(ctx.get_full_transcript().split())
-        status = f'<div class="status-bar">🎤 Listening... buffering audio ({len(state["audio_buffer"])}/{samples_needed} samples)</div>'
+    buffer_samples = len(state["audio_buffer"])
+    buffer_pct = int(buffer_samples / samples_needed * 100)
+    word_count = len(state.get("transcript", "").split())
+    is_transcribing = state.get("transcription_in_progress", False)
+    is_generating = state.get("generation_in_progress", False)
+
+    # Build status parts
+    status_parts = [f"🎤 Buffer: {buffer_pct}%", f"📝 {word_count} words"]
+    if is_transcribing:
+        status_parts.append("🔄 Transcribing...")
+    if is_generating:
+        status_parts.append("⚙️ Generating...")
+
+    status = f'<div class="status-bar">{" | ".join(status_parts)}</div>'
+
+    # Check if we have enough audio to process (CHUNK_DURATION seconds)
+    if buffer_samples < samples_needed:
+        return (
+            state.get("transcript", ""),
+            state.get("log_html", format_activity_log(activity_log)),
+            state.get("questions_html", format_questions_html(state.get("questions", []))),
+            status,
+            state
+        )
+
+    # Check if transcription is already running (sequential queue)
+    if is_transcribing:
+        # Keep buffering, don't start new transcription yet
         return (
             state.get("transcript", ""),
             state.get("log_html", format_activity_log(activity_log)),
@@ -136,107 +222,31 @@ def process_streaming_audio(
         )
 
     # Process the buffered audio with overlap
-    audio_to_process = state["audio_buffer"][:samples_needed]
+    audio_to_process = state["audio_buffer"][:samples_needed].copy()  # Copy for thread safety
     # Keep last OVERLAP_DURATION seconds for next chunk to prevent word cutoffs
     overlap_samples = sample_rate * OVERLAP_DURATION
     state["audio_buffer"] = state["audio_buffer"][samples_needed - overlap_samples:]
 
-    try:
-        # Save to temp file for Whisper
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-            import wave
-            with wave.open(f.name, 'wb') as wav:
-                wav.setnchannels(1)
-                wav.setsampwidth(2)
-                wav.setframerate(sample_rate)
-                wav.writeframes((audio_to_process * 32767).astype(np.int16).tobytes())
-            temp_path = f.name
-
-        # Transcribe
-        new_text = transcribe_audio(temp_path)
-        os.unlink(temp_path)
-
-        if new_text.strip():
-            ctx.add_transcript(new_text)
-            state["transcript"] = ctx.get_full_transcript()
-
-            current_word_count = len(state["transcript"].split())
-            words_since_last = current_word_count - state.get("last_word_count", 0)
-
-            # Add transcription to activity log
-            activity_log.append({"type": "transcribe", "words": current_word_count})
-            state["activity_log"] = activity_log
-
-            # Check if word cap reached
-            if current_word_count >= MAX_WORDS_CAP:
-                status = f'<div class="status-bar" style="border-color:#f59e0b;">⚠️ Word limit reached ({MAX_WORDS_CAP} words). Clear session to continue.</div>'
-                state["log_html"] = format_activity_log(activity_log)
-                return (
-                    state["transcript"],
-                    state["log_html"],
-                    state.get("questions_html", format_questions_html([])),
-                    status,
-                    state
-                )
-
-            status = f'<div class="status-bar">🎤 Listening... {current_word_count} words captured</div>'
-
-            # Check if we should generate questions
-            should_generate = (
-                current_word_count >= MIN_WORDS_FOR_QUESTIONS and
-                words_since_last >= WORDS_BETWEEN_GENERATIONS and
-                not state.get("generation_in_progress", False)  # Don't start if already generating
-            )
-
-            if should_generate:
-                state["last_word_count"] = current_word_count
-                state["generation_in_progress"] = True
-
-                # Start background thread for question generation (non-blocking)
-                thread = threading.Thread(
-                    target=generate_questions_background,
-                    args=(state,),
-                    daemon=True
-                )
-                thread.start()
-
-                status = f'<div class="status-bar">🎤 Listening... {current_word_count} words | ⚙️ Generating questions...</div>'
-            else:
-                # Update log HTML
-                state["log_html"] = format_activity_log(activity_log)
-
-                # Show appropriate status
-                if state.get("generation_in_progress", False):
-                    status = f'<div class="status-bar">🎤 Listening... {current_word_count} words | ⚙️ Generating questions...</div>'
-                elif current_word_count < MIN_WORDS_FOR_QUESTIONS:
-                    need_more = MIN_WORDS_FOR_QUESTIONS - current_word_count
-                    status = f'<div class="status-bar">🎤 Listening... {current_word_count} words (need {need_more} more to start generating)</div>'
-
-            return (
-                state["transcript"],
-                state["log_html"],
-                state.get("questions_html", format_questions_html([])),
-                status,
-                state
-            )
+    # Start background transcription (non-blocking)
+    state["transcription_in_progress"] = True
+    thread = threading.Thread(
+        target=transcribe_audio_background,
+        args=(audio_to_process, sample_rate, state),
+        daemon=True
+    )
+    thread.start()
 
-    except Exception as e:
-        activity_log.append({"type": "error", "msg": str(e)})
-        state["activity_log"] = activity_log
-        state["log_html"] = format_activity_log(activity_log)
-        return (
-            state.get("transcript", ""),
-            state["log_html"],
-            state.get("questions_html", format_questions_html([])),
-            f'<div class="status-bar" style="border-color:#ef4444;">❌ Error: {str(e)}</div>',
-            state
-        )
+    # Update status to show transcribing started
+    status_parts = [f"🎤 Buffer: {int(overlap_samples / samples_needed * 100)}%", f"📝 {word_count} words", "🔄 Transcribing..."]
+    if is_generating:
+        status_parts.append("⚙️ Generating...")
+    status = f'<div class="status-bar">{" | ".join(status_parts)}</div>'
 
     return (
         state.get("transcript", ""),
-        state.get("log_html", format_activity_log([])),
-        state.get("questions_html", format_questions_html([])),
-        '<div class="status-bar">Processing...</div>',
+        state.get("log_html", format_activity_log(activity_log)),
+        state.get("questions_html", format_questions_html(state.get("questions", []))),
+        status,
         state
     )