Update app.py

app.py

@@ -57,48 +57,70 @@ def apply_speaker_renames_to_df(df, fileIndex, column="task"):
 def extract_speaker_clip(audio_path, annotation, speaker, clip_duration=5):
     """
     Extract a clip of up to clip_duration seconds for the given speaker.
-    Prefers the first segment >= clip_duration seconds; falls back to the longest segment.
-    Returns bytes (WAV) or None on failure.
+    Returns (bytes, None) on success, or (None, error_string) on failure.
     """
+    import io, traceback
     try:
-        import io
-        # Collect all segments for this speaker
-        speaker_segments = [
-            (seg.start, seg.end)
-            for seg, _, label in annotation.itertracks(yield_label=True)
-            if label == speaker
-        ]
+        # --- Step 1: collect segments for this speaker ---
+        speaker_segments = []
+        try:
+            for seg, _, label in annotation.itertracks(yield_label=True):
+                if label == speaker:
+                    speaker_segments.append((seg.start, seg.end))
+        except Exception as e:
+            return None, f"itertracks failed: {e}"
+
         if not speaker_segments:
-            return None
+            return None, f"No segments found for speaker '{speaker}' in annotation"
 
-        # Prefer first segment long enough for a full clip
+        # --- Step 2: pick best segment ---
         chosen_start, chosen_end = None, None
         for start, end in speaker_segments:
             if (end - start) >= clip_duration:
                 chosen_start, chosen_end = start, start + clip_duration
                 break
-
-        # Fall back: use the longest segment available
         if chosen_start is None:
             longest = max(speaker_segments, key=lambda s: s[1] - s[0])
             chosen_start, chosen_end = longest
 
-        # Load audio and slice the clip
-        waveform, sample_rate = torchaudio.load(audio_path)
+        # --- Step 3: load audio with torchaudio, fallback to soundfile ---
+        waveform, sample_rate = None, None
+        load_errors = []
+        try:
+            waveform, sample_rate = torchaudio.load(audio_path)
+        except Exception as e:
+            load_errors.append(f"torchaudio.load: {e}")
+
+        if waveform is None:
+            try:
+                import soundfile as sf
+                import numpy as np
+                data, sample_rate = sf.read(audio_path, dtype='float32')
+                if data.ndim == 1:
+                    data = data[np.newaxis, :]
+                else:
+                    data = data.T
+                waveform = torch.from_numpy(data)
+            except Exception as e:
+                load_errors.append(f"soundfile: {e}")
+
+        if waveform is None:
+            return None, "Could not load audio: " + " | ".join(load_errors)
+
+        # --- Step 4: slice and encode ---
         start_frame = int(chosen_start * sample_rate)
         end_frame = min(int(chosen_end * sample_rate), waveform.shape[-1])
         clip = waveform[:, start_frame:end_frame]
 
-        # Encode as WAV in memory
         buffer = io.BytesIO()
         torchaudio.save(buffer, clip, sample_rate, format="wav")
         buffer.seek(0)
-        return buffer.read()
+        return buffer.read(), None
+
     except Exception as e:
-        import traceback
-        print(f"extract_speaker_clip error for {speaker}: {e}")
-        traceback.print_exc()
-        return None
+        msg = traceback.format_exc()
+        print(f"extract_speaker_clip unexpected error for {speaker}: {msg}")
+        return None, str(e)
 
 @st.cache_data
 def convert_df(df):
@@ -669,15 +691,15 @@ try:
                 for sp in speakerNames:
                     _display = get_display_name(sp, currFileIndex)
                     st.sidebar.markdown(f"**{_display}**")
-                    _clip_bytes = extract_speaker_clip(
+                    _clip_bytes, _clip_err = extract_speaker_clip(
                         _curr_audio_path, currAnnotation, sp, clip_duration=5
                     )
                     if _clip_bytes:
                         st.sidebar.audio(_clip_bytes, format="audio/wav")
                     else:
-                        st.sidebar.caption("_(No audio segment found)_")
+                        st.sidebar.error(f"Clip error: {_clip_err}")
             else:
-                st.sidebar.caption("_(Audio file not available for preview)_")
+                st.sidebar.warning(f"Audio file not found at path: {_curr_audio_path}")
 
         st.sidebar.divider()
         st.sidebar.subheader("Rename Speakers")