Create app.py

app.py

@@ -0,0 +1,265 @@
+import gradio as gr
+import re
+import difflib
+from typing import List, Dict, Tuple, Optional
+import numpy as np
+from dataclasses import dataclass
+
+@dataclass
+class Segment:
+    """Represents a transcript segment"""
+    speaker: str
+    timestamp: str
+    text: str
+    raw_text: str  # For matching purposes - original text without formatting
+
+@dataclass
+class Match:
+    """Represents a match between segments"""
+    auto_index: int
+    human_index: int
+    similarity: float
+
+def parse_auto_transcript(transcript: str) -> List[Segment]:
+    """Parse the auto-generated transcript"""
+    # Pattern to match "Speaker X 00:00:00" followed by text
+    pattern = r"(?:\*\*)?Speaker (\w+)(?:\*\*)? (?:\*)?(\d{2}:\d{2}:\d{2})(?:\*)?\s*\n\n(.*?)(?=\n\n(?:\*\*)?Speaker |\Z)"
+    segments = []
+    
+    for match in re.finditer(pattern, transcript, re.DOTALL):
+        speaker, timestamp, text = match.groups()
+        # Remove any markdown formatting for matching purposes
+        raw_text = re.sub(r'\*\*|\*', '', text.strip())
+        segments.append(Segment(speaker, timestamp, text.strip(), raw_text))
+    
+    return segments
+
+def parse_human_transcript(transcript: str) -> List[Segment]:
+    """Parse the human-edited transcript"""
+    # Pattern to match both markdown and plain text formats
+    # This handles both "**Speaker X** *00:00:00*" and "Speaker X 00:00:00"
+    pattern = r"(?:\*\*)?(?:Speaker )?(\w+)(?:\*\*)? (?:\*)?(\d{2}:\d{2}:\d{2})(?:\*)?\s*\n\n(.*?)(?=\n\n(?:\*\*)?(?:Speaker )?|\Z)"
+    segments = []
+    
+    for match in re.finditer(pattern, transcript, re.DOTALL):
+        speaker, timestamp, text = match.groups()
+        # Remove any markdown formatting for matching purposes
+        raw_text = re.sub(r'\*\*|\*|\[.*?\]\(.*?\)', '', text.strip())
+        segments.append(Segment(speaker, timestamp, text.strip(), raw_text))
+    
+    return segments
+
+def similarity_score(text1: str, text2: str) -> float:
+    """Calculate similarity between two text segments"""
+    # Remove all markdown, punctuation, and lowercase for better matching
+    clean1 = re.sub(r'[^\w\s]', '', text1.lower())
+    clean2 = re.sub(r'[^\w\s]', '', text2.lower())
+    
+    # Use difflib's SequenceMatcher for similarity
+    return difflib.SequenceMatcher(None, clean1, clean2).ratio()
+
+def find_best_matches(auto_segments: List[Segment], human_segments: List[Segment]) -> List[Match]:
+    """Find the best matching segments between auto and human transcripts"""
+    matches = []
+    used_human_indices = set()
+    
+    # First pass: Find obvious matches (high similarity)
+    for auto_idx, auto_segment in enumerate(auto_segments):
+        best_match_idx = -1
+        best_similarity = 0.0
+        
+        for human_idx, human_segment in enumerate(human_segments):
+            if human_idx in used_human_indices:
+                continue
+                
+            similarity = similarity_score(auto_segment.raw_text, human_segment.raw_text)
+            
+            if similarity > best_similarity and similarity >= 0.6:  # Threshold for a good match
+                best_similarity = similarity
+                best_match_idx = human_idx
+        
+        if best_match_idx >= 0:
+            matches.append(Match(auto_idx, best_match_idx, best_similarity))
+            used_human_indices.add(best_match_idx)
+    
+    # Second pass: Try to match remaining segments with a lower threshold
+    for auto_idx, auto_segment in enumerate(auto_segments):
+        if any(m.auto_index == auto_idx for m in matches):
+            continue
+            
+        best_match_idx = -1
+        best_similarity = 0.0
+        
+        for human_idx, human_segment in enumerate(human_segments):
+            if human_idx in used_human_indices:
+                continue
+                
+            similarity = similarity_score(auto_segment.raw_text, human_segment.raw_text)
+            
+            if similarity > best_similarity and similarity >= 0.4:  # Lower threshold
+                best_similarity = similarity
+                best_match_idx = human_idx
+        
+        if best_match_idx >= 0:
+            matches.append(Match(auto_idx, best_match_idx, best_similarity))
+            used_human_indices.add(best_match_idx)
+    
+    return matches
+
+def update_timestamps(auto_segments: List[Segment], human_segments: List[Segment], matches: List[Match]) -> str:
+    """Update timestamps in human transcript based on matches"""
+    # Create a new list for the updated segments
+    updated_segments = human_segments.copy()
+    
+    for match in matches:
+        auto_segment = auto_segments[match.auto_index]
+        human_segment = human_segments[match.human_index]
+        
+        # Update the timestamp in the human segment
+        updated_segments[match.human_index] = Segment(
+            speaker=human_segment.speaker,
+            timestamp=auto_segment.timestamp,
+            text=human_segment.text,
+            raw_text=human_segment.raw_text
+        )
+    
+    # Generate the updated transcript
+    result = []
+    for segment in updated_segments:
+        # Check if this is a markdown-formatted transcript
+        if "**" in human_segments[0].text or "*" in human_segments[0].timestamp:
+            result.append(f"**{segment.speaker}** *{segment.timestamp}*\n\n{segment.text}")
+        else:
+            result.append(f"Speaker {segment.speaker} {segment.timestamp}\n\n{segment.text}")
+    
+    return "\n\n".join(result)
+
+def find_unmatched_segments(auto_segments: List[Segment], matches: List[Match]) -> List[int]:
+    """Find segments in the auto transcript that weren't matched"""
+    matched_auto_indices = {match.auto_index for match in matches}
+    return [i for i in range(len(auto_segments)) if i not in matched_auto_indices]
+
+def format_unmatched_segments(auto_segments: List[Segment], unmatched_indices: List[int], is_markdown: bool) -> str:
+    """Format unmatched segments for display"""
+    if not unmatched_indices:
+        return "No unmatched segments found"
+    
+    result = []
+    for idx in unmatched_indices:
+        segment = auto_segments[idx]
+        if is_markdown:
+            result.append(f"**Speaker {segment.speaker}** *{segment.timestamp}*\n\n{segment.text}")
+        else:
+            result.append(f"Speaker {segment.speaker} {segment.timestamp}\n\n{segment.text}")
+    
+    return "### Unmatched Segments (New Content)\n\n" + "\n\n".join(result)
+
+def process_transcripts(auto_transcript: str, human_transcript: str):
+    """Process transcripts and update timestamps"""
+    # Parse both transcripts
+    auto_segments = parse_auto_transcript(auto_transcript)
+    human_segments = parse_human_transcript(human_transcript)
+    
+    # Early check for empty inputs
+    if not auto_segments or not human_segments:
+        return "Error: Could not parse one or both transcripts. Please check the format.", "", ""
+        
+    # Find matches between segments
+    matches = find_best_matches(auto_segments, human_segments)
+    
+    # Find unmatched segments
+    unmatched_indices = find_unmatched_segments(auto_segments, matches)
+    
+    # Determine if we're using markdown
+    is_markdown = "**" in human_transcript or "*" in human_transcript
+    
+    # Update timestamps
+    updated_transcript = update_timestamps(auto_segments, human_segments, matches)
+    
+    # Format unmatched segments
+    unmatched_segments = format_unmatched_segments(auto_segments, unmatched_indices, is_markdown)
+    
+    # Stats about the matching
+    stats = f"### Matching Statistics\n\n"
+    stats += f"- Auto-generated segments: {len(auto_segments)}\n"
+    stats += f"- Human-edited segments: {len(human_segments)}\n"
+    stats += f"- Matched segments: {len(matches)}\n"
+    stats += f"- Unmatched segments: {len(unmatched_indices)}\n"
+    
+    # Add match quality histogram
+    if matches:
+        similarities = [match.similarity for match in matches]
+        stats += f"- Average match similarity: {sum(similarities)/len(similarities):.2f}\n"
+        
+        # Histogram of match qualities
+        bins = [0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
+        hist, _ = np.histogram(similarities, bins=bins)
+        stats += "\n#### Match Quality Distribution\n\n"
+        for i, count in enumerate(hist):
+            lower = bins[i]
+            upper = bins[i+1]
+            stats += f"- {lower:.1f}-{upper:.1f}: {count} matches\n"
+    
+    return updated_transcript, unmatched_segments, stats
+
+# Create Gradio interface
+with gr.Blocks(title="Transcript Timestamp Updater") as demo:
+    gr.Markdown("""
+    # Transcript Timestamp Updater
+    
+    This tool updates timestamps in a human-edited transcript based on a new auto-generated transcript.
+    
+    ## Instructions:
+    1. Paste your new auto-generated transcript (with updated timestamps)
+    2. Paste your human-edited transcript (with old timestamps)
+    3. Click "Update Timestamps" to generate a new version of the human-edited transcript with updated timestamps
+    
+    The tool will try to match segments between the two transcripts and update the timestamps accordingly.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            auto_transcript = gr.Textbox(
+                label="New Auto-Generated Transcript (with updated timestamps)",
+                placeholder="Paste the new auto-generated transcript here...",
+                lines=15
+            )
+        
+        with gr.Column():
+            human_transcript = gr.Textbox(
+                label="Human-Edited Transcript (with old timestamps)",
+                placeholder="Paste your human-edited transcript here...",
+                lines=15
+            )
+    
+    update_btn = gr.Button("Update Timestamps")
+    
+    with gr.Tabs():
+        with gr.TabItem("Updated Transcript"):
+            updated_transcript = gr.TextArea(
+                label="Updated Human Transcript",
+                placeholder="The updated transcript will appear here...",
+                lines=20
+            )
+        
+        with gr.TabItem("Unmatched Segments"):
+            unmatched_segments = gr.Markdown(
+                label="Unmatched Segments",
+                value="Unmatched segments will appear here..."
+            )
+        
+        with gr.TabItem("Statistics"):
+            stats = gr.Markdown(
+                label="Matching Statistics",
+                value="Statistics will appear here..."
+            )
+    
+    update_btn.click(
+        fn=process_transcripts,
+        inputs=[auto_transcript, human_transcript],
+        outputs=[updated_transcript, unmatched_segments, stats]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()