status in result tab got more informative

frontend/app.js

@@ -228,7 +228,6 @@ async function handleTranscription() {
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
-    setStatus('Processing audio...', 'info');
 
     while (true) {
       const { done, value } = await reader.read();
@@ -265,12 +264,20 @@ function handleTranscriptionEvent(event) {
         elements.audioPlayer.currentTime = 0;
       }
       break;
-    case 'utterance':
-      if (event.utterance) {
-        state.utterances.push(event.utterance);
-        renderTranscript();
+    case 'status':
+      setStatus(event.message, 'info');
+      break;
+    case 'progress':
+      if (event.stage === 'diarization') {
+        setStatus(`Performing speaker diarization... (${event.progress}%)`, 'info');
       }
       break;
+    case 'utterance':
+      state.utterances.push(event.utterance);
+      const progress = event.progress || 0;
+      setStatus(`Transcribing audio... (${state.utterances.length} utterances, ${progress}%)`, 'info');
+      renderTranscript();
+      break;
     case 'complete':
       if (event.diarization) {
         state.diarizedUtterances = event.diarization.utterances || [];

src/asr.py

@@ -42,7 +42,7 @@ def transcribe_file(
     backend: str = "moonshine",
     language: str = "auto",
     textnorm: str = "withitn",
-) -> Iterable[Tuple[Optional[Tuple[float, float, str]], List[Tuple[float, float, str]]]]:
+) -> Iterable[Tuple[Optional[Tuple[float, float, str]], List[Tuple[float, float, str]], float]]:
     """
     Transcribe audio file using specified backend.
     
@@ -124,7 +124,8 @@ def transcribe_file(
                 
                 if text:
                     utterances.append((segment_start, segment_end, cleaned_text))
-                    yield utterances[-1], utterances.copy()
+                    progress = min(100, (i / len(wav)) * 100)
+                    yield utterances[-1], utterances.copy(), progress
                 
                 # Reset for next segment
                 speech_chunks = []
@@ -154,10 +155,10 @@ def transcribe_file(
             
             if text:
                 utterances.append((segment_start, segment_end, cleaned_text))
-                yield utterances[-1], utterances.copy()
+                yield utterances[-1], utterances.copy(), 100.0
 
     # Final yield with all utterances
     if utterances:
-        yield None, utterances
+        yield None, utterances, 100.0
     else:
-        yield None, [(-1, -1, "No speech detected")]
+        yield None, [(-1, -1, "No speech detected")], 100.0

src/diarization.py

@@ -211,8 +211,8 @@ def perform_speaker_diarization_on_utterances(
         batch_size = max(1, total_utterances // 20)  # Process in batches for progress updates
         
         for i, (start, end, text) in enumerate(utterances):
-            if progress_callback and i % batch_size == 0:
-                progress_callback(i / total_utterances * 0.8)  # 80% for embedding extraction
+            if i % batch_size == 0:
+                yield i / total_utterances * 0.8
             
             # Extract audio segment
             start_sample = int(start * sample_rate)
@@ -279,6 +279,7 @@ def perform_speaker_diarization_on_utterances(
             
             if progress_callback:
                 progress_callback(0.9)  # 90% for clustering
+            yield 0.9
             
             # Run enhanced diarization
             try:
@@ -316,6 +317,7 @@ def perform_speaker_diarization_on_utterances(
                 
                 if progress_callback:
                     progress_callback(1.0)  # 100% complete
+                yield 1.0
                 
                 print(f"✅ DEBUG: Enhanced result - {n_speakers} speakers, {len(diarization_result)} segments")
                 logger.info(f"🎭 Enhanced clustering completed! Detected {n_speakers} speakers with {confidence} confidence")
@@ -332,8 +334,14 @@ def perform_speaker_diarization_on_utterances(
         print("⚠️ Using fallback clustering")
 
         # >>> NOUVEAU : clustering FAISS si disponible, sinon ancien code
-        diarization_result = faiss_clustering(embeddings_array, valid_utterances,
+        gen = faiss_clustering(embeddings_array, valid_utterances,
                                               config_dict, progress_callback)
+        try:
+            while True:
+                p = next(gen)
+                yield p
+        except StopIteration as e:
+            diarization_result = e.value
         
         return diarization_result
         
@@ -509,7 +517,7 @@ def get_diarization_stats(
 def faiss_clustering(embeddings: np.ndarray,
                      utterances: list,
                      config_dict: dict,
-                     progress_callback=None) -> list:
+                     progress_callback=None):
     """
     Clustering via FAISS (K-means) ultra-rapide CPU.
     Retourne la liste (start, end, speaker_id) compatible avec l'ancien code.
@@ -518,7 +526,13 @@ def faiss_clustering(embeddings: np.ndarray,
         import faiss
     except ImportError:
         # FAISS absent → on retombe sur AgglomerativeClustering d'origine
-        return sklearn_fallback_clustering(embeddings, utterances, config_dict, progress_callback)
+        gen = sklearn_fallback_clustering(embeddings, utterances, config_dict, progress_callback)
+        try:
+            while True:
+                p = next(gen)
+                yield p
+        except StopIteration as e:
+            return e.value
 
     n_samples, dim = embeddings.shape
     n_clusters = config_dict['num_speakers']
@@ -543,6 +557,7 @@ def faiss_clustering(embeddings: np.ndarray,
 
     if progress_callback:
         progress_callback(1.0)
+    yield 1.0
 
     num_speakers = len(set(labels))
     print(f"✅ DEBUG: FAISS clustering — {num_speakers} speakers, {len(utterances)} segments")
@@ -578,8 +593,10 @@ def sklearn_fallback_clustering(embeddings, utterances, config_dict, progress_ca
 
     if progress_callback:
         progress_callback(0.9)
+    yield 0.9
     labels = clustering.fit_predict(distance_matrix)
     if progress_callback:
         progress_callback(1.0)
+    yield 1.0
 
     return [(start, end, int(lbl)) for (start, end, _), lbl in zip(utterances, labels)]

src/server/services/asr_service.py

@@ -65,22 +65,38 @@ def iter_transcription_events(
             "model": model_name,
         }
 
+        yield {
+            "type": "status",
+            "message": "Transcribing audio...",
+        }
+
         final_utterances: List[Tuple[float, float, str]] = []
 
-        for current_utterance, all_utterances in generator:
+        for current_utterance, all_utterances, progress in generator:
             if current_utterance:
                 start, end, text = current_utterance
                 yield {
                     "type": "utterance",
                     "utterance": _serialize_utterance((start, end, text)),
                     "index": len(all_utterances) - 1,
+                    "progress": round(progress, 1),
                 }
             final_utterances = list(all_utterances)
 
         # Final event with transcript and optional diarization
         diarization_payload = None
         if options.diarization.enable:
-            diarization_payload = _run_diarization(audio_path, final_utterances, options.diarization)
+            yield {
+                "type": "status",
+                "message": "Performing speaker diarization...",
+            }
+            diarization_gen = _run_diarization(audio_path, final_utterances, options.diarization)
+            for event in diarization_gen:
+                if event["type"] == "progress":
+                    yield event
+                elif event["type"] == "result":
+                    diarization_payload = event["payload"]
+                    break
 
         transcript_text = "\n".join([utt[2] for utt in final_utterances])
 
@@ -99,16 +115,18 @@ def _run_diarization(
     audio_path: Path,
     utterances: List[Tuple[float, float, str]],
     options: DiarizationOptions,
-) -> Optional[Dict[str, object]]:
+):
     if not utterances:
-        return None
+        yield {"type": "result", "payload": None}
+        return
 
     extractor_result = init_speaker_embedding_extractor(
         cluster_threshold=options.cluster_threshold,
         num_speakers=options.num_speakers,
     )
     if not extractor_result:
-        return None
+        yield {"type": "result", "payload": None}
+        return
 
     embedding_extractor, config_dict = extractor_result
 
@@ -124,7 +142,7 @@ def _run_diarization(
         audio = resample(audio, target_num_samples)
         sample_rate = 16000
 
-    diarization_segments = perform_speaker_diarization_on_utterances(
+    diarization_gen = perform_speaker_diarization_on_utterances(
         audio=audio,
         sample_rate=sample_rate,
         utterances=utterances,
@@ -133,17 +151,30 @@ def _run_diarization(
         progress_callback=None,
     )
 
+    diarization_segments = None
+    try:
+        while True:
+            item = next(diarization_gen)
+            if isinstance(item, float):
+                yield {"type": "progress", "stage": "diarization", "progress": round(item * 100, 1)}
+            else:
+                diarization_segments = item
+                break
+    except StopIteration as e:
+        diarization_segments = e.value
+
     if not diarization_segments:
-        return None
+        yield {"type": "result", "payload": None}
+        return
 
     merged = merge_transcription_with_diarization(utterances, diarization_segments)
     merged = merge_consecutive_utterances(merged, max_gap=1.0)
     stats = get_diarization_stats(merged)
 
-    return {
+    yield {"type": "result", "payload": {
         "utterances": [
             _serialize_utterance((start, end, text), speaker)
             for start, end, text, speaker in merged
         ],
         "stats": stats,
-    }
+    }}