Create segmenter.py

segmenter.py

@@ -0,0 +1,144 @@
+# segmenter.py - Text segmentation and speaker assignment
+import re
+from typing import List, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+class TextSegmenter:
+    def __init__(self):
+        self.speakers = ["speaker1", "speaker2", "speaker3", "speaker4"]
+        self.current_speaker_index = 0
+    
+    def segment_and_assign_speakers(
+        self, 
+        text: str, 
+        mode: str = "auto"
+    ) -> List[Tuple[str, str]]:
+        """
+        Segment text and assign speakers.
+        
+        Args:
+            text: Input text to segment
+            mode: Segmentation mode ("auto", "paragraph", "dialogue")
+            
+        Returns:
+            List of (speaker, text) tuples
+        """
+        if mode == "paragraph":
+            return self._segment_by_paragraphs(text)
+        elif mode == "dialogue":
+            return self._segment_by_dialogue(text)
+        else:  # auto mode
+            return self._segment_auto(text)
+    
+    def _segment_by_paragraphs(self, text: str) -> List[Tuple[str, str]]:
+        """Segment by paragraphs, alternating speakers."""
+        paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+        segments = []
+        
+        for i, paragraph in enumerate(paragraphs):
+            speaker = self.speakers[i % len(self.speakers)]
+            segments.append((speaker, paragraph))
+        
+        return segments
+    
+    def _segment_by_dialogue(self, text: str) -> List[Tuple[str, str]]:
+        """Segment by detecting dialogue patterns."""
+        # Look for dialogue markers like quotes, dashes, etc.
+        lines = text.split('\n')
+        segments = []
+        current_segment = []
+        current_speaker = self.speakers[0]
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Check for dialogue markers
+            if (line.startswith('"') or line.startswith("'") or 
+                line.startswith('-') or line.startswith('—')):
+                
+                # Save previous segment
+                if current_segment:
+                    segments.append((current_speaker, ' '.join(current_segment)))
+                
+                # Switch speaker and start new segment
+                self.current_speaker_index = (self.current_speaker_index + 1) % len(self.speakers)
+                current_speaker = self.speakers[self.current_speaker_index]
+                current_segment = [line]
+            else:
+                current_segment.append(line)
+        
+        # Add final segment
+        if current_segment:
+            segments.append((current_speaker, ' '.join(current_segment)))
+        
+        return segments
+    
+    def _segment_auto(self, text: str) -> List[Tuple[str, str]]:
+        """Automatic segmentation using multiple heuristics."""
+        # Try to detect natural breaks
+        segments = []
+        
+        # Split by double newlines first (paragraphs)
+        paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+        
+        if len(paragraphs) > 1:
+            # Use paragraph-based segmentation
+            return self._segment_by_paragraphs(text)
+        
+        # Fall back to sentence-based segmentation for long text
+        sentences = self._split_into_sentences(text)
+        if len(sentences) > 10:
+            return self._segment_by_sentence_groups(sentences)
+        
+        # For short text, just alternate every few sentences
+        return self._segment_simple(text)
+    
+    def _split_into_sentences(self, text: str) -> List[str]:
+        """Split text into sentences."""
+        # Simple sentence splitting
+        sentences = re.split(r'[.!?]+', text)
+        return [s.strip() for s in sentences if s.strip()]
+    
+    def _segment_by_sentence_groups(self, sentences: List[str]) -> List[Tuple[str, str]]:
+        """Group sentences and assign to different speakers."""
+        segments = []
+        group_size = max(2, len(sentences) // 8)  # Aim for reasonable segment sizes
+        
+        for i in range(0, len(sentences), group_size):
+            group = sentences[i:i + group_size]
+            speaker = self.speakers[i // group_size % len(self.speakers)]
+            text_segment = '. '.join(group) + '.'
+            segments.append((speaker, text_segment))
+        
+        return segments
+    
+    def _segment_simple(self, text: str) -> List[Tuple[str, str]]:
+        """Simple segmentation for short texts."""
+        # Just split roughly in half or thirds
+        words = text.split()
+        total_words = len(words)
+        
+        if total_words < 50:
+            # Too short to split meaningfully
+            return [("speaker1", text)]
+        
+        # Split into 2-3 segments
+        num_segments = min(3, max(2, total_words // 100))
+        segment_size = total_words // num_segments
+        
+        segments = []
+        for i in range(num_segments):
+            start_idx = i * segment_size
+            end_idx = (i + 1) * segment_size if i < num_segments - 1 else total_words
+            
+            segment_words = words[start_idx:end_idx]
+            segment_text = ' '.join(segment_words)
+            speaker = self.speakers[i % len(self.speakers)]
+            
+            segments.append((speaker, segment_text))
+        
+        return segments