fix processor & UI

app/services/processor.py

@@ -140,96 +140,70 @@ class Processor:
 
         t0= time.time()
 
-        # Step 1: Convert to WAV
+        # 1: Convert to WAV
         logger.info("Step 1: Converting audio to WAV 16kHz...")
         wav_path = await asyncio.get_event_loop().run_in_executor(None, convert_audio_to_wav, audio_path)
 
-        # Step 2: Load audio
+        # 2: Load audio
         y, sr = librosa.load(wav_path, sr=16000, mono=True)
         if y.size == 0:
             raise ValueError("Empty audio")
         waveform = torch.from_numpy(y).unsqueeze(0).float()
         duration = len(y) / sr
         
-        # Step 3: Diarization
+        # 3: Diarization
         logger.info("Step 3: Running diarization...")
         
-        try:
-            diarization_result: DiarizationResult = (
-                await DiarizationService.diarize_async(wav_path)
-            )
-
-            diarization_segments = diarization_result.segments
-            speaker_count = diarization_result.speaker_count
-            speakers = diarization_result.speakers
-            roles = diarization_result.roles
-            
+        diarization: DiarizationResult = await DiarizationService.diarize_async(wav_path)
 
-        except Exception as e:
-            logger.error(f"Diarization failed: {e}")
-            diarization_segments = []
+        diarization_segments = diarization.segments or []
+        speakers = diarization.speakers or []
+        roles = diarization.roles or {}
 
         if not diarization_segments:
-            diarization_segments = [SpeakerSegment(0.0, duration, "Speaker 1")]
-            speaker_count = 1
-            speakers = ["Speaker 1"]
-            roles = {"Speaker 1": "UNKNOWN"}
-        
-        if not roles:
-            roles = {
-                speaker: "UNKNOWN"
-                for speaker in speakers
-            }
-         # Sort by start time
+            diarization_segments = [SpeakerSegment(0.0, duration, "SPEAKER_0")]
+            speakers = ["SPEAKER_0"]
+            roles = {"SPEAKER_0": "KH"}
+
         diarization_segments.sort(key=lambda x: x.start)
 
-        # Step 4: Refine segment boundaries
+        # 4: Refine segment boundaries
         refined_segments: List[SpeakerSegment] = []
-
         for seg in diarization_segments:
-            start_idx = int(seg.start * sr)
-            end_idx = int(seg.end * sr)
-
-            if pad_refine:
-                refined = pad_and_refine_tensor(
-                    waveform, sr, seg.start, seg.end
-                )
-                if refined:
-                    start_idx, end_idx = refined
-
-            if end_idx <= start_idx:
+            refined = pad_and_refine_tensor(waveform, sr, seg.start, seg.end)
+            if not refined:
                 continue
-
+            s, e = refined
             refined_segments.append(
                 SpeakerSegment(
-                    start=start_idx / sr,
-                    end=end_idx / sr,
-                    speaker=seg.speaker or "Speaker 1"
+                    start=s / sr,
+                    end=e / sr,
+                    speaker=seg.speaker,
                 )
             )
+
         if not refined_segments:
             refined_segments = diarization_segments
     
-        logger.info(f"Refined segments: {len(refined_segments)}")
-        speaker_duration = defaultdict(float)
-        for seg in refined_segments:
-            speaker_duration[seg.speaker] += seg.end - seg.start
+        # 5. Normalize speakers
+        speakers = sorted({seg.speaker for seg in refined_segments})
+        speaker_count = len(speakers)
+
+        # 6. Infer role ONLY if diarization did not provide
+        if not roles:
+            speaker_duration = defaultdict(float)
+            for seg in refined_segments:
+                speaker_duration[seg.speaker] += seg.end - seg.start
 
-        if speaker_duration:
             agent = max(speaker_duration, key=speaker_duration.get)
             roles = {
-                speaker: ("NV" if speaker == agent else "KH")
-                for speaker in speaker_duration
+                spk: ("NV" if spk == agent else "KH")
+                for spk in speaker_duration
             }
-        else:
-            roles = {}
-            
         for spk in speakers:
             roles.setdefault(spk, "KH")
             
-        speaker_count = len(speakers)
-        
-        # Step 5: Transcribe
+        # 7: Transcribe
         vad_options = None
         if vad_filter:
             vad_options = {
@@ -275,7 +249,7 @@ class Processor:
                     start=seg.start,
                     end=seg.end,
                     speaker=seg.speaker,
-                    role=roles.get(seg.speaker, "UNKNOWN"),
+                    role=roles.get(seg.speaker, "KH"),
                     text=text.strip(),
                 )
             )
@@ -285,8 +259,8 @@ class Processor:
                 TranscriptSegment(
                     start=0.0,
                     end=duration,
-                    speaker="Speaker 1",
-                    role="UNKNOWN",
+                    speaker=speakers[0],
+                    role=roles[speakers[0]],
                     text="(No speech detected)"
                 )
             ]
@@ -299,8 +273,8 @@ class Processor:
         txt_content = cls._generate_txt(
             processed_segments,
             speaker_count,
-            processing_time,
             duration,
+            processing_time,
             roles
         )