Update app.py

app.py

@@ -114,19 +114,66 @@ def processFile(filePath):
     print("Time in seconds calculated")
     return annotations, totalTimeInSeconds, waveform_gain_adjusted, sampleRate
 
+def _extract_clip_bytes(waveform, sample_rate, seg_start, seg_end):
+    """
+    Extract a 3–5 s clip from [seg_start, seg_end] by finding the loudest
+    RMS window within that range. Returns raw WAV bytes.
+    """
+    import io
+    import soundfile as sf
+
+    CLIP_MIN = 3.0
+    CLIP_MAX = 5.0
+    STEP = 0.5  # scanning step in seconds
+
+    total_samples = waveform.shape[-1]
+    seg_start_s = int(seg_start * sample_rate)
+    seg_end_s   = min(int(seg_end   * sample_rate), total_samples)
+    seg_len_s   = seg_end_s - seg_start_s
+
+    # Duration of this segment in seconds
+    seg_dur = (seg_end_s - seg_start_s) / sample_rate
+
+    # Clip duration: between CLIP_MIN and CLIP_MAX, capped by segment length
+    clip_dur = min(max(min(seg_dur, CLIP_MAX), CLIP_MIN), seg_dur)
+    clip_samples = int(clip_dur * sample_rate)
+
+    best_start = seg_start_s
+    best_rms   = -1.0
+
+    # Slide a window and pick the loudest position
+    step_samples = int(STEP * sample_rate)
+    pos = seg_start_s
+    while pos + clip_samples <= seg_end_s:
+        window = waveform[:, pos: pos + clip_samples].float()
+        rms = float(window.pow(2).mean().sqrt())
+        if rms > best_rms:
+            best_rms   = rms
+            best_start = pos
+        pos += step_samples
+
+    clip_waveform = waveform[:, best_start: best_start + clip_samples]
+    clip_np = clip_waveform.numpy().T  # (samples, channels)
+    buf = io.BytesIO()
+    sf.write(buf, clip_np, sample_rate, format="WAV", subtype="PCM_16")
+    buf.seek(0)
+    return buf.read()
+
+
 def generate_speaker_clips(annotations, waveform, sample_rate, 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.
-    Accepts the already-loaded waveform tensor and sample_rate from processFile,
-    so this never needs to re-decode the audio file (avoids torchcodec/FFmpeg issues).
+    For each unique speaker in `annotations`:
+      - Store all their segments in st.session_state.speakerSegments[file_index][speaker].
+      - Pick the loudest 3–5 s window within their longest segment as the default clip.
     Saves clips as WAV bytes in st.session_state.speakerClips[file_index].
     """
-    import io
+    # Initialise speakerSegments store if needed
+    if 'speakerSegments' not in st.session_state:
+        st.session_state.speakerSegments = {}
+
+    clips    = {}
+    segments = {}
 
-    # file_index is now a filename string
-    clips = {}
     for speaker in annotations.labels():
         speaker_segments = [
             segment for segment, _, label in annotations.itertracks(yield_label=True)
@@ -135,26 +182,61 @@ def generate_speaker_clips(annotations, waveform, sample_rate, file_index):
         if not speaker_segments:
             continue
 
+        # Persist all segments so the randomize button can draw from them later
+        segments[speaker] = [(s.start, s.end) for s in speaker_segments]
+
         longest = max(speaker_segments, key=lambda s: s.duration)
+        clips[speaker] = _extract_clip_bytes(
+            waveform, sample_rate, longest.start, longest.end
+        )
+
+    st.session_state.speakerClips[file_index]    = clips
+    st.session_state.speakerSegments[file_index] = segments
+    print(f"Generated {len(clips)} speaker clips for {file_index}")
 
-        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 = min(int(clip_end * sample_rate), waveform.shape[-1])
+def randomize_speaker_clip(file_index, speaker):
+    """
+    Pick a random segment (weighted by duration) for `speaker` and extract
+    a random 3–5 s window from it. Updates speakerClips in session_state.
+    Requires that st.session_state.speakerWaveforms[file_index] is present.
+    """
+    import random
 
-        clip_waveform = waveform[:, start_sample:end_sample]
+    segs = st.session_state.speakerSegments.get(file_index, {}).get(speaker)
+    waveform_data = st.session_state.speakerWaveforms.get(file_index)
+    if not segs or waveform_data is None:
+        return
 
-        import soundfile as sf
-        clip_np = clip_waveform.numpy().T  # (channels, samples) -> (samples, channels)
-        buffer = io.BytesIO()
-        sf.write(buffer, clip_np, sample_rate, format="WAV", subtype="PCM_16")
-        buffer.seek(0)
-        clips[speaker] = buffer.read()
+    waveform, sample_rate = waveform_data
 
-    st.session_state.speakerClips[file_index] = clips
-    print(f"Generated {len(clips)} speaker clips for {file_index}")
+    CLIP_MIN = 3.0
+    CLIP_MAX = 5.0
+
+    # Weight selection by segment duration so longer segments are more likely
+    durations  = [max(e - s, 0.01) for s, e in segs]
+    total_dur  = sum(durations)
+    rand_val   = random.random() * total_dur
+    cumulative = 0.0
+    chosen_start, chosen_end = segs[0]
+    for (seg_s, seg_e), dur in zip(segs, durations):
+        cumulative += dur
+        if rand_val <= cumulative:
+            chosen_start, chosen_end = seg_s, seg_e
+            break
+
+    seg_dur  = chosen_end - chosen_start
+    clip_dur = min(max(min(seg_dur, CLIP_MAX), CLIP_MIN), seg_dur)
+
+    # Random offset within the chosen segment
+    max_offset = max(seg_dur - clip_dur, 0.0)
+    offset     = random.uniform(0.0, max_offset)
+    clip_start = chosen_start + offset
+    clip_end   = clip_start + clip_dur
+
+    new_clip = _extract_clip_bytes(waveform, sample_rate, clip_start, clip_end)
+    st.session_state.speakerClips[file_index][speaker] = new_clip
+    print(f"Randomized clip for {speaker} in {file_index}: {clip_start:.2f}–{clip_end:.2f}s")
 
 def addCategory():
     newCategory = st.session_state.categoryInput
@@ -418,7 +500,11 @@ if 'file_paths' not in st.session_state:
 if 'showSummary' not in st.session_state:
     st.session_state.showSummary = 'No'
 if 'speakerClips' not in st.session_state:
-    st.session_state.speakerClips = {}   # {filename: {speaker: wav_bytes}}
+    st.session_state.speakerClips = {}     # {filename: {speaker: wav_bytes}}
+if 'speakerSegments' not in st.session_state:
+    st.session_state.speakerSegments = {}  # {filename: {speaker: [(start,end), ...]}}
+if 'speakerWaveforms' not in st.session_state:
+    st.session_state.speakerWaveforms = {} # {filename: (waveform_tensor, sample_rate)}
 if 'analyzeAllToggle' not in st.session_state:
     st.session_state.analyzeAllToggle = False
     
@@ -610,6 +696,8 @@ if st.session_state.analyzeAllToggle == True:
                 st.session_state.unusedSpeakers[fname] = list(annotations.labels())
             with st.spinner(text=f'Generating speaker clips for File {i+1} of {totalFiles}'):
                 generate_speaker_clips(annotations, waveform, sample_rate, fname)
+                # Keep a reference so the "Try Another Clip" button can re-sample later
+                st.session_state.speakerWaveforms[fname] = (waveform, sample_rate)
                 del waveform
                 print(f"Speaker clips generated for {fpath}")
         with st.spinner(text=f'Analyzing File {i+1} of {totalFiles}'):
@@ -678,7 +766,8 @@ try:
         file_clips = st.session_state.speakerClips.get(currFile, {})
         if file_clips:
             st.sidebar.caption(
-                "Listen to each speaker's longest clip (up to 5 s) to help identify them."
+                "Listen to a short clip (3–5 s) to help identify each speaker. "
+                "If a clip sounds silent or unclear, press 🔀 to try a different one."
             )
 
         current_renames = st.session_state.speakerRenames[currFile]
@@ -692,6 +781,17 @@ try:
             st.sidebar.markdown(f"**{display_label}**")
             if sp in file_clips:
                 st.sidebar.audio(file_clips[sp], format="audio/wav")
+                # Only show randomize button if there are multiple segments to draw from
+                sp_segs = st.session_state.speakerSegments.get(currFile, {}).get(sp, [])
+                has_waveform = currFile in st.session_state.speakerWaveforms
+                if has_waveform and len(sp_segs) >= 1:
+                    if st.sidebar.button(
+                        "🔀 Try Another Clip",
+                        key=f"randomize_{currFile}_{sp}",
+                        help="Pick a random clip from a different part of this speaker's audio",
+                    ):
+                        randomize_speaker_clip(currFile, sp)
+                        st.rerun()
             # Label is always the fixed original sp so Streamlit never recreates the widget
             new_name = st.sidebar.text_input(
                 sp,