Update app.py

app.py

@@ -53,54 +53,7 @@ def apply_speaker_renames_to_df(df, fileIndex, column="task"):
     df = df.copy()
     df[column] = df[column].apply(lambda s: get_display_name(s, fileIndex))
     return df
-
-def extract_speaker_clip(annotation, speaker, waveform, sample_rate, clip_duration=5):
-    """
-    Slice a clip directly from the already-loaded waveform tensor.
-    Avoids torchaudio.load (broken in this env due to torchcodec/libnppicc).
-    Returns (wav_bytes, None) on success or (None, error_str) on failure.
-    """
-    import io, traceback as tb
-    try:
-        if waveform is None or sample_rate is None:
-            return None, "No waveform stored (only audio uploads carry waveform data)"
-
-        # Collect this speaker's segments
-        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, f"No segments found for speaker '{speaker}'"
-
-        # Prefer first segment >= clip_duration; else take longest
-        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
-        if chosen_start is None:
-            longest = max(speaker_segments, key=lambda s: s[1] - s[0])
-            chosen_start, chosen_end = longest
-
-        # Slice waveform
-        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 to WAV bytes
-        buf = io.BytesIO()
-        torchaudio.save(buf, clip.cpu(), sample_rate, format="wav")
-        buf.seek(0)
-        return buf.read(), None
-
-    except Exception as e:
-        print(f"extract_speaker_clip error for {speaker}: {tb.format_exc()}")
-        return None, str(e)
+    
 @st.cache_data
 def convert_df(df):
    return df.to_csv(index=False).encode('utf-8')
@@ -161,7 +114,62 @@ def processFile(filePath):
     print("Speakers Detected")
     totalTimeInSeconds = int(waveform_gain_adjusted.shape[-1]/sampleRate)
     print("Time in seconds calculated")
-    return annotations, totalTimeInSeconds, waveform_gain_adjusted, sampleRate
+    return annotations, totalTimeInSeconds
+
+def generate_speaker_clips(annotations, audio_path, file_index):
+    """
+    For each unique speaker in `annotations`, find their longest contiguous segment.
+    If that segment is >= 5s, clip exactly 5s from its start.
+    If < 5s, take the whole segment.
+    Saves clips as WAV bytes in st.session_state.speakerClips[file_index].
+    Only works when a real audio file is provided (skips silently otherwise).
+    """
+    if audio_path is None or not os.path.exists(audio_path):
+        return
+
+    # Extend speakerClips list to cover this file index
+    while len(st.session_state.speakerClips) <= file_index:
+        st.session_state.speakerClips.append({})
+
+    try:
+        waveform, sample_rate = torchaudio.load(audio_path)
+    except Exception as e:
+        print(f"generate_speaker_clips: could not load audio: {e}")
+        return
+
+    clips = {}
+    for speaker in annotations.labels():
+        # Collect all segments for this speaker
+        speaker_segments = [
+            segment for segment, _, label in annotations.itertracks(yield_label=True)
+            if label == speaker
+        ]
+        if not speaker_segments:
+            continue
+
+        # Find the longest segment
+        longest = max(speaker_segments, key=lambda s: s.duration)
+
+        # Determine clip boundaries
+        clip_start = longest.start
+        clip_duration = min(longest.duration, 5.0)
+        clip_end = clip_start + clip_duration
+
+        start_sample = int(clip_start * sample_rate)
+        end_sample = int(clip_end * sample_rate)
+        end_sample = min(end_sample, waveform.shape[-1])
+
+        clip_waveform = waveform[:, start_sample:end_sample]
+
+        # Write to an in-memory bytes buffer as WAV
+        import io
+        buffer = io.BytesIO()
+        torchaudio.save(buffer, clip_waveform, sample_rate, format="wav")
+        buffer.seek(0)
+        clips[speaker] = buffer.read()
+
+    st.session_state.speakerClips[file_index] = clips
+    print(f"Generated {len(clips)} speaker clips for file index {file_index}")
 
 def addCategory():
     newCategory = st.session_state.categoryInput
@@ -188,7 +196,7 @@ def updateCategoryOptions(resultIndex):
     #st.info(f"Updating result {resultIndex}")
     #st.info(f"In update: {st.session_state.categorySelect}")
     # Handle 
-    _r = st.session_state.results[currFileIndex]; currAnnotation = _r[0]
+    _, currAnnotation, _ = st.session_state.results[currFileIndex]
     speakerNames = currAnnotation.labels()
 
     # Handle speaker category sidebars
@@ -221,7 +229,7 @@ def analyze(inFileName):
             
             printV(f'In if',4)
             # Handle 
-            _r = st.session_state.results[currFileIndex]; currAnnotation, currTotalTime = _r[0], _r[1]
+            currAnnotation, currTotalTime = st.session_state.results[currFileIndex]
             speakerNames = currAnnotation.labels()
             printV(f'Loaded results',4)
             # Update other categories
@@ -421,6 +429,8 @@ if 'file_paths' not in st.session_state:
     st.session_state.file_paths = []
 if 'showSummary' not in st.session_state:
     st.session_state.showSummary = 'No'
+if 'speakerClips' not in st.session_state:
+    st.session_state.speakerClips = []  # List of dicts: {speaker_label: wav_bytes} per file
     
 
     
@@ -443,9 +453,7 @@ viewChoices = ["Voice Categories","Custom Categories","Detailed Voice Categories
 valid_files = st.session_state.valid_files
 file_paths = st.session_state.file_paths
 currDF = None
-if 'temp_dir' not in st.session_state:
-    st.session_state.temp_dir = tempfile.mkdtemp()
-temp_dir = st.session_state.temp_dir
+temp_dir = tempfile.mkdtemp()
 
 if uploaded_file_paths is not None and len(uploaded_file_paths) > 0:
     print("Found file paths")
@@ -481,6 +489,8 @@ if uploaded_file_paths is not None and len(uploaded_file_paths) > 0:
         st.session_state.summaries.append([])
     while (len(st.session_state.speakerRenames) < len(valid_files)):
         st.session_state.speakerRenames.append({})
+    while (len(st.session_state.speakerClips) < len(valid_files)):
+        st.session_state.speakerClips.append({})
         
     st.session_state.file_names = file_names
     st.session_state.valid_files = valid_files
@@ -546,15 +556,18 @@ else:
                         st.session_state.unusedSpeakers[i] = speakerNames
                 else:
                     with st.spinner(text=f'Processing File {i+1} of {totalFiles}'):
-                        annotations, totalSeconds, wf_stored, sr_stored = processFile(file_paths[i])
+                        annotations, totalSeconds = processFile(file_paths[i])
                         print(f"Finished processing {file_paths[i]}")
-                        st.session_state.results[i] = (annotations, totalSeconds, wf_stored, sr_stored)
+                        st.session_state.results[i] = (annotations, totalSeconds)
                         print("Results saved")
                         st.session_state.summaries[i] = {}
                         print("Summaries saved")
                         speakerNames = annotations.labels()
                         st.session_state.unusedSpeakers[i] = speakerNames 
                         print("Speakers saved")
+                    with st.spinner(text=f'Generating speaker clips for File {i+1} of {totalFiles}'):
+                        generate_speaker_clips(annotations, file_paths[i], i)
+                        print(f"Speaker clips generated for {file_paths[i]}")
                 with st.spinner(text=f'Analyzing File {i+1} of {totalFiles}'):
                     analyze(file_names[i])
                     print(f"Finished analyzing {file_paths[i]}")
@@ -593,6 +606,8 @@ if st.sidebar.button("Load Demo Example"):
         st.session_state.summaries.append([])
     while (len(st.session_state.speakerRenames) < len(valid_files)):
         st.session_state.speakerRenames.append({})
+    while (len(st.session_state.speakerClips) < len(valid_files)):
+        st.session_state.speakerClips.append({})
         
     with st.spinner(text=f'Loading Demo Sample'):
         # RTTM load as filler
@@ -631,10 +646,7 @@ try:
         graphNames = ["Data","Voice Categories","Speaker Percentage","Speakers with Categories","Treemap","Timeline","Time Spoken"]
         dataTab, pie1, pie2, sunburst1, treemap1, timeline, bar1 = st.tabs(graphNames)
         # Handle 
-        _r = st.session_state.results[currFileIndex]
-        currAnnotation, currTotalTime = _r[0], _r[1]
-        currWaveform   = _r[2] if len(_r) > 2 else None
-        currSampleRate = _r[3] if len(_r) > 3 else None
+        currAnnotation, currTotalTime = st.session_state.results[currFileIndex]
         speakerNames = currAnnotation.labels()
     
         speakers_dataFrame = st.session_state.summaries[currFileIndex]["speakers_dataFrame"]
@@ -658,39 +670,30 @@ try:
        
         newCategory = st.sidebar.text_input('Add category', key='categoryInput',on_change=addCategory) 
 
-        # --- Speaker Sample Clips (audio files only) ---
-        _is_audio_file = currFile is not None and not any(
-            currFile.lower().endswith(ext) for ext in ('.rttm', '.txt', '.csv')
+        st.sidebar.divider()
+        st.sidebar.subheader("Rename Speakers")
+        st.sidebar.caption("Replace SPEAKER_## labels with real names.")
+
+        # --- Speaker clip preview ---
+        file_clips = (
+            st.session_state.speakerClips[currFileIndex]
+            if currFileIndex < len(st.session_state.speakerClips)
+            else {}
         )
-        if _is_audio_file:
-            st.sidebar.divider()
-            st.sidebar.subheader("\U0001f3a7 Speaker Samples")
+        if file_clips:
             st.sidebar.caption(
-                "Listen to a 5-second clip for each speaker to help identify them."
+                "Listen to each speaker's longest clip (up to 5 s) to help identify them."
             )
-            _curr_audio_path = file_paths[currFileIndex] if currFileIndex < len(file_paths) else None
-            if _curr_audio_path and os.path.exists(_curr_audio_path):
-                for sp in speakerNames:
-                    _display = get_display_name(sp, currFileIndex)
-                    st.sidebar.markdown(f"**{_display}**")
-                    _clip_bytes, _clip_err = extract_speaker_clip(
-                        currAnnotation, sp, currWaveform, currSampleRate, clip_duration=5
-                    )
-                    if _clip_bytes:
-                        st.sidebar.audio(_clip_bytes, format="audio/wav")
-                    else:
-                        st.sidebar.error(f"Clip error: {_clip_err}")
-            else:
-                st.sidebar.warning(f"Audio path not found: {_curr_audio_path}")
 
-        st.sidebar.divider()
-        st.sidebar.subheader("Rename Speakers")
-        st.sidebar.caption("Replace SPEAKER_## labels with real names.")
         current_renames = st.session_state.speakerRenames[currFileIndex]
         for sp in speakerNames:
+            display_label = current_renames.get(sp, sp)
+            st.sidebar.markdown(f"**{display_label}**")
+            if sp in file_clips:
+                st.sidebar.audio(file_clips[sp], format="audio/wav")
             current_label = current_renames.get(sp, "")
             new_name = st.sidebar.text_input(
-                f"{sp}",
+                f"Rename {sp}",
                 value=current_label,
                 placeholder=f"e.g. John",
                 key=f"rename_{currFileIndex}_{sp}"
@@ -1102,7 +1105,7 @@ if len(st.session_state.results) > 0:
                 }
                 allCategories = copy.deepcopy(st.session_state.categories)
                 for i in indices:
-                    _ri = st.session_state.results[i]; currAnnotation, currTotalTime = _ri[0], _ri[1]
+                    currAnnotation, currTotalTime = st.session_state.results[i]
                     categorySelections = st.session_state["categorySelect"][i]
                     catSummary,extraCats = su.calcCategories(currAnnotation,categorySelections)
                     st.session_state.summaries[i]["categories"] = (catSummary,extraCats)