lyrics-transcriber 0.30.0__py3-none-any.whl → 0.32.1__py3-none-any.whl

lyrics_transcriber/correction/handlers/relaxed_word_count_match.py

@@ -0,0 +1,55 @@
+from typing import List, Tuple, Dict, Any, Optional
+
+from lyrics_transcriber.types import GapSequence, WordCorrection
+from lyrics_transcriber.correction.handlers.base import GapCorrectionHandler
+from lyrics_transcriber.correction.handlers.word_operations import WordOperations
+
+
+class RelaxedWordCountMatchHandler(GapCorrectionHandler):
+    """Handles gaps where at least one reference source has matching word count."""
+
+    def can_handle(self, gap: GapSequence) -> Tuple[bool, Dict[str, Any]]:
+        # Must have reference words
+        if not gap.reference_words:
+            return False, {}
+
+        # Check if any source has matching word count
+        for words in gap.reference_words.values():
+            if len(words) == gap.length:
+                return True, {}
+
+        return False, {}
+
+    def handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> List[WordCorrection]:
+        corrections = []
+
+        # Find the first source that has matching word count
+        matching_source = None
+        reference_words = None
+        reference_words_original = None
+        for source, words in gap.reference_words.items():
+            if len(words) == gap.length:
+                matching_source = source
+                reference_words = words
+                reference_words_original = gap.reference_words_original[source]
+                break
+
+        # Use the centralized method to calculate reference positions for the matching source
+        reference_positions = WordOperations.calculate_reference_positions(gap, [matching_source])
+
+        # Since we found a source with matching word count, we can correct using that source
+        for i, (orig_word, ref_word, ref_word_original) in enumerate(zip(gap.words, reference_words, reference_words_original)):
+            if orig_word.lower() != ref_word.lower():
+                corrections.append(
+                    WordOperations.create_word_replacement_correction(
+                        original_word=orig_word,
+                        corrected_word=ref_word_original,
+                        original_position=gap.transcription_position + i,
+                        source=matching_source,
+                        confidence=1.0,
+                        reason=f"RelaxedWordCountMatchHandler: Source '{matching_source}' had matching word count",
+                        reference_positions=reference_positions,
+                    )
+                )
+
+        return corrections

lyrics_transcriber/correction/handlers/repeat.py

@@ -0,0 +1,71 @@
+from typing import List, Dict, Optional, Tuple, Any
+from lyrics_transcriber.types import GapSequence, WordCorrection
+from lyrics_transcriber.correction.handlers.base import GapCorrectionHandler
+from lyrics_transcriber.correction.handlers.word_operations import WordOperations
+import logging
+
+
+class RepeatCorrectionHandler(GapCorrectionHandler):
+    """Handler that applies corrections that were previously made by other handlers."""
+
+    def __init__(self, logger: Optional[logging.Logger] = None, confidence_threshold: float = 0.7):
+        self.logger = logger or logging.getLogger(__name__)
+        self.confidence_threshold = confidence_threshold
+        self.previous_corrections: List[WordCorrection] = []
+
+    def can_handle(self, gap: GapSequence) -> Tuple[bool, Dict[str, Any]]:
+        """Check if any words in the gap match previous corrections."""
+        return bool(self.previous_corrections), {}
+
+    def set_previous_corrections(self, corrections: List[WordCorrection]) -> None:
+        """Store corrections from previous handlers to use as reference."""
+        self.previous_corrections = corrections
+
+    def handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> List[WordCorrection]:
+        """Apply previous corrections to matching words in the current gap."""
+        corrections = []
+
+        # Use the centralized method to calculate reference positions
+        reference_positions = WordOperations.calculate_reference_positions(gap)
+
+        # Build a map of original words to their corrections
+        correction_map: Dict[str, List[WordCorrection]] = {}
+        for corr in self.previous_corrections:
+            if corr.confidence >= self.confidence_threshold:
+                correction_map.setdefault(corr.original_word.lower(), []).append(corr)
+
+        # Check each word in the gap
+        for i, word in enumerate(gap.words):
+            word_lower = word.lower()
+            if word_lower in correction_map:
+                # Get the most common correction for this word
+                prev_corrections = correction_map[word_lower]
+                best_correction = max(
+                    prev_corrections,
+                    key=lambda c: (sum(1 for pc in prev_corrections if pc.corrected_word == c.corrected_word), c.confidence),
+                )
+
+                self.logger.debug(
+                    f"Applying previous correction: {word} -> {best_correction.corrected_word} "
+                    f"(confidence: {best_correction.confidence:.2f})"
+                )
+
+                corrections.append(
+                    WordCorrection(
+                        original_word=word,
+                        corrected_word=best_correction.corrected_word,
+                        segment_index=0,
+                        original_position=gap.transcription_position + i,
+                        confidence=best_correction.confidence * 0.9,  # Slightly lower confidence for repeats
+                        source=best_correction.source,
+                        reason=f"RepeatCorrectionHandler: Matches previous correction",
+                        alternatives={best_correction.corrected_word: 1},
+                        is_deletion=best_correction.is_deletion,
+                        reference_positions=reference_positions,  # Add reference positions
+                        length=best_correction.length,  # Preserve length from original correction
+                        split_index=best_correction.split_index,  # Preserve split info if present
+                        split_total=best_correction.split_total,  # Preserve split info if present
+                    )
+                )
+
+        return corrections

lyrics_transcriber/correction/handlers/sound_alike.py

@@ -0,0 +1,223 @@
+from typing import List, Dict, Tuple, Optional, Any
+import logging
+from metaphone import doublemetaphone
+from lyrics_transcriber.types import GapSequence, WordCorrection
+from lyrics_transcriber.correction.handlers.base import GapCorrectionHandler
+from lyrics_transcriber.correction.handlers.word_operations import WordOperations
+
+
+class SoundAlikeHandler(GapCorrectionHandler):
+    """Handles gaps where words sound similar to reference words but are spelled differently.
+
+    Uses Double Metaphone algorithm to detect sound-alike words. For each word in the gap,
+    it checks if its phonetic encoding matches any reference word's encoding.
+
+    The confidence of corrections is based on:
+    1. The ratio of reference sources agreeing on the correction
+    2. Whether the match was on primary (1.0) or secondary (0.8) metaphone code
+
+    Examples:
+        Gap: "shush look deep"
+        References:
+            genius: ["search", "look", "deep"]
+            spotify: ["search", "look", "deep"]
+        Result:
+            - Correct "shush" to "search" (confidence based on metaphone match type)
+            - Validate "look" and "deep" (exact matches)
+    """
+
+    def __init__(self, logger: Optional[logging.Logger] = None, similarity_threshold: float = 0.6):
+        """Initialize the handler.
+
+        Args:
+            logger: Optional logger instance
+            similarity_threshold: Minimum confidence threshold for matches (default: 0.6)
+        """
+        self.logger = logger or logging.getLogger(__name__)
+        self.similarity_threshold = similarity_threshold
+
+    def can_handle(self, gap: GapSequence) -> Tuple[bool, Dict[str, Any]]:
+        # Must have reference words
+        if not gap.reference_words:
+            self.logger.debug("No reference words available")
+            return False, {}
+
+        # Gap must have words
+        if not gap.words:
+            self.logger.debug("No gap words available")
+            return False, {}
+
+        # Check if any gap word has a metaphone match with any reference word
+        for word in gap.words:
+            word_codes = doublemetaphone(word)
+            self.logger.debug(f"Gap word '{word}' has metaphone codes: {word_codes}")
+            for ref_words in gap.reference_words.values():
+                for ref_word in ref_words:
+                    ref_codes = doublemetaphone(ref_word)
+                    self.logger.debug(f"Reference word '{ref_word}' has metaphone codes: {ref_codes}")
+                    if self._codes_match(word_codes, ref_codes):
+                        self.logger.debug(f"Found metaphone match between '{word}' and '{ref_word}'")
+                        return True, {}
+        self.logger.debug("No metaphone matches found")
+        return False, {}
+
+    def handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> List[WordCorrection]:
+        corrections = []
+
+        # Use the centralized method to calculate reference positions for all sources
+        reference_positions = WordOperations.calculate_reference_positions(gap)
+
+        # For each word in the gap
+        for i, word in enumerate(gap.words):
+            word_codes = doublemetaphone(word)
+            self.logger.debug(f"Processing '{word}' (codes: {word_codes})")
+
+            # Skip if word exactly matches any reference
+            exact_match = any(i < len(ref_words) and word.lower() == ref_words[i].lower() for ref_words in gap.reference_words.values())
+            if exact_match:
+                continue
+
+            # Find sound-alike matches in references
+            matches: Dict[str, Tuple[List[str], float]] = {}
+
+            for source, ref_words in gap.reference_words.items():
+                ref_words_original = gap.reference_words_original[source]  # Get original formatted words
+                for j, (ref_word, ref_word_original) in enumerate(zip(ref_words, ref_words_original)):
+                    ref_codes = doublemetaphone(ref_word)
+
+                    match_confidence = self._get_match_confidence(word_codes, ref_codes)
+                    if match_confidence >= self.similarity_threshold:
+                        # Special handling for short codes - don't apply position penalty
+                        is_short_code = any(len(c) <= 2 for c in word_codes if c) or any(len(c) <= 2 for c in ref_codes if c)
+                        position_multiplier = 1.0 if is_short_code or i == j else 0.8
+
+                        adjusted_confidence = match_confidence * position_multiplier
+
+                        if adjusted_confidence >= self.similarity_threshold:
+                            if ref_word_original not in matches:  # Use original formatted word as key
+                                matches[ref_word_original] = ([], adjusted_confidence)
+                            matches[ref_word_original][0].append(source)
+
+            # Create correction for best match if any found
+            if matches:
+                best_match, (sources, base_confidence) = max(matches.items(), key=lambda x: (len(x[1][0]), x[1][1]))
+
+                source_confidence = len(sources) / len(gap.reference_words)
+                final_confidence = base_confidence * source_confidence
+
+                self.logger.debug(f"Found match: {word} -> {best_match} (confidence: {final_confidence:.2f}, sources: {sources})")
+                corrections.append(
+                    WordCorrection(
+                        original_word=word,
+                        corrected_word=best_match,  # Already using original formatted word
+                        segment_index=0,
+                        original_position=gap.transcription_position + i,
+                        confidence=final_confidence,
+                        source=", ".join(sources),
+                        reason=f"SoundAlikeHandler: Phonetic match ({final_confidence:.2f} confidence)",
+                        alternatives={k: len(v[0]) for k, v in matches.items()},
+                        is_deletion=False,
+                        reference_positions=reference_positions,  # Add reference positions
+                        length=1,  # Single word replacement
+                    )
+                )
+
+        return corrections
+
+    def _codes_match(self, codes1: Tuple[str, str], codes2: Tuple[str, str]) -> float:
+        """Check if two sets of metaphone codes match and return match quality."""
+        # Get all non-empty codes
+        codes1_set = {c for c in codes1 if c}
+        codes2_set = {c for c in codes2 if c}
+
+        if not codes1_set or not codes2_set:
+            return 0.0
+
+        best_match = 0.0
+        for code1 in codes1_set:
+            for code2 in codes2_set:
+                # Special case for very short codes (like 'A' for 'you')
+                if len(code1) <= 2 or len(code2) <= 2:
+                    if code1 == code2:
+                        best_match = max(best_match, 1.0)
+                    elif code1 in code2 or code2 in code1:
+                        best_match = max(best_match, 0.8)
+                    elif code1[0] == code2[0]:  # Match first character
+                        best_match = max(best_match, 0.7)
+                    continue
+
+                # Skip if codes are too different in length
+                length_diff = abs(len(code1) - len(code2))
+                if length_diff > 3:
+                    continue
+
+                # Exact match
+                if code1 == code2:
+                    best_match = max(best_match, 1.0)
+                    continue
+
+                # Similar codes (allow 1-2 character differences)
+                if len(code1) >= 2 and len(code2) >= 2:
+                    # Compare first N characters where N is min length
+                    min_len = min(len(code1), len(code2))
+
+                    # Check for shared characters in any position
+                    shared_chars = sum(1 for c in code1 if c in code2)
+                    if shared_chars >= min(2, min_len):  # More lenient shared character requirement
+                        match_quality = 0.7 + (0.1 * shared_chars / max(len(code1), len(code2)))
+                        best_match = max(best_match, match_quality)
+                        continue
+
+                    # Compare aligned characters
+                    differences = sum(1 for a, b in zip(code1[:min_len], code2[:min_len]) if a != b)
+                    if differences <= 2:
+                        match_quality = 0.85 - (differences * 0.1)
+                        best_match = max(best_match, match_quality)
+                        continue
+
+                # Common prefix/suffix match with more lenient threshold
+                common_prefix_len = 0
+                for a, b in zip(code1, code2):
+                    if a != b:
+                        break
+                    common_prefix_len += 1
+
+                common_suffix_len = 0
+                for a, b in zip(code1[::-1], code2[::-1]):
+                    if a != b:
+                        break
+                    common_suffix_len += 1
+
+                if common_prefix_len >= 1 or common_suffix_len >= 1:  # Even more lenient prefix/suffix requirement
+                    match_quality = 0.7 + (0.1 * max(common_prefix_len, common_suffix_len))
+                    best_match = max(best_match, match_quality)
+                    continue
+
+                # Substring match
+                if len(code1) >= 2 and len(code2) >= 2:  # More lenient length requirement
+                    # Look for shared substrings of length 2 or more
+                    for length in range(min(len(code1), len(code2)), 1, -1):
+                        for i in range(len(code1) - length + 1):
+                            substring = code1[i : i + length]
+                            if substring in code2:
+                                match_quality = 0.7 + (0.1 * length / max(len(code1), len(code2)))
+                                best_match = max(best_match, match_quality)
+                                break
+
+        return best_match
+
+    def _get_match_confidence(self, codes1: Tuple[str, str], codes2: Tuple[str, str]) -> float:
+        """Calculate confidence score for a metaphone code match."""
+        match_quality = self._codes_match(codes1, codes2)
+        if match_quality == 0:
+            return 0.0
+
+        # Get primary codes (first code of each tuple)
+        code1, code2 = codes1[0], codes2[0]
+
+        # Boost confidence for codes that share prefixes
+        if code1 and code2 and len(code1) >= 2 and len(code2) >= 2:
+            if code1[:2] == code2[:2]:
+                match_quality = min(1.0, match_quality + 0.1)
+
+        return match_quality

lyrics_transcriber/correction/handlers/syllables_match.py

@@ -0,0 +1,182 @@
+from typing import List, Tuple, Dict, Any
+import spacy
+import logging
+import pyphen
+import nltk
+from nltk.corpus import cmudict
+import syllables
+from spacy_syllables import SpacySyllables
+
+from lyrics_transcriber.types import GapSequence, WordCorrection
+from lyrics_transcriber.correction.handlers.base import GapCorrectionHandler
+from lyrics_transcriber.correction.handlers.word_operations import WordOperations
+
+
+class SyllablesMatchHandler(GapCorrectionHandler):
+    """Handles gaps where number of syllables in reference text matches number of syllables in transcription."""
+
+    def __init__(self):
+        # Marking SpacySyllables as used to prevent unused import warning
+        _ = SpacySyllables
+        # Load spacy model with syllables pipeline
+        self.nlp = spacy.load("en_core_web_sm")
+        # Add syllables component to pipeline if not already present
+        if "syllables" not in self.nlp.pipe_names:
+            self.nlp.add_pipe("syllables", after="tagger")
+        # Initialize Pyphen for English
+        self.dic = pyphen.Pyphen(lang="en_US")
+        # Initialize NLTK's CMU dictionary
+        try:
+            self.cmudict = cmudict.dict()
+        except LookupError:
+            nltk.download("cmudict")
+            self.cmudict = cmudict.dict()
+        self.logger = logging.getLogger(__name__)
+
+    def _count_syllables_spacy(self, words: List[str]) -> int:
+        """Count syllables using spacy_syllables."""
+        text = " ".join(words)
+        doc = self.nlp(text)
+        total_syllables = sum(token._.syllables_count or 1 for token in doc)
+        return total_syllables
+
+    def _count_syllables_pyphen(self, words: List[str]) -> int:
+        """Count syllables using pyphen."""
+        total_syllables = 0
+        for word in words:
+            hyphenated = self.dic.inserted(word)
+            syllables_count = len(hyphenated.split("-")) if hyphenated else 1
+            total_syllables += syllables_count
+        return total_syllables
+
+    def _count_syllables_nltk(self, words: List[str]) -> int:
+        """Count syllables using NLTK's CMU dictionary."""
+        total_syllables = 0
+        for word in words:
+            word = word.lower()
+            if word in self.cmudict:
+                syllables_count = len([ph for ph in self.cmudict[word][0] if ph[-1].isdigit()])
+                total_syllables += syllables_count
+            else:
+                total_syllables += 1
+        return total_syllables
+
+    def _count_syllables_lib(self, words: List[str]) -> int:
+        """Count syllables using the syllables library."""
+        total_syllables = 0
+        for word in words:
+            syllables_count = syllables.estimate(word)
+            total_syllables += syllables_count
+        return total_syllables
+
+    def _count_syllables(self, words: List[str]) -> List[int]:
+        """Count syllables using multiple methods."""
+        spacy_count = self._count_syllables_spacy(words)
+        pyphen_count = self._count_syllables_pyphen(words)
+        nltk_count = self._count_syllables_nltk(words)
+        syllables_count = self._count_syllables_lib(words)
+
+        text = " ".join(words)
+        self.logger.debug(
+            f"Syllable counts for '{text}': spacy={spacy_count}, pyphen={pyphen_count}, nltk={nltk_count}, syllables={syllables_count}"
+        )
+        return [spacy_count, pyphen_count, nltk_count, syllables_count]
+
+    def can_handle(self, gap: GapSequence) -> Tuple[bool, Dict[str, Any]]:
+        # Must have reference words
+        if not gap.reference_words:
+            self.logger.debug("No reference words available")
+            return False, {}
+
+        # Get syllable counts for gap text using different methods
+        gap_syllables = self._count_syllables(gap.words)
+
+        # Check if any reference source has matching syllable count with any method
+        for source, words in gap.reference_words.items():
+            ref_syllables = self._count_syllables(words)
+
+            # If any counting method matches between gap and reference, we can handle it
+            if any(gap_count == ref_count for gap_count in gap_syllables for ref_count in ref_syllables):
+                self.logger.debug(f"Found matching syllable count in source '{source}'")
+                return True, {
+                    "gap_syllables": gap_syllables,
+                    "matching_source": source,
+                    "reference_words": words,
+                    "reference_words_original": gap.reference_words_original[source],
+                }
+
+        self.logger.debug("No reference source had matching syllable count")
+        return False, {}
+
+    def handle(self, gap: GapSequence, data: Dict[str, Any]) -> List[WordCorrection]:
+        corrections = []
+        matching_source = data["matching_source"]
+        reference_words = data["reference_words"]
+        reference_words_original = data["reference_words_original"]
+
+        # Use the centralized method to calculate reference positions
+        reference_positions = WordOperations.calculate_reference_positions(gap, [matching_source])
+
+        # Since we matched syllable counts for the entire gap, we should handle all words
+        if len(gap.words) > len(reference_words):
+            # Multiple transcribed words -> fewer reference words
+            # Try to distribute the reference words across the gap words
+            words_per_ref = len(gap.words) / len(reference_words)
+
+            for ref_idx, ref_word_original in enumerate(reference_words_original):
+                start_idx = int(ref_idx * words_per_ref)
+                end_idx = int((ref_idx + 1) * words_per_ref)
+
+                # Get the group of words to combine
+                words_to_combine = gap.words[start_idx:end_idx]
+                corrections.extend(
+                    WordOperations.create_word_combine_corrections(
+                        original_words=words_to_combine,
+                        reference_word=ref_word_original,
+                        original_position=gap.transcription_position + start_idx,
+                        source=matching_source,
+                        confidence=0.8,
+                        combine_reason="SyllablesMatchHandler: Words combined based on syllable match",
+                        delete_reason="SyllablesMatchHandler: Word removed as part of syllable match combination",
+                        reference_positions=reference_positions,
+                    )
+                )
+
+        elif len(gap.words) < len(reference_words):
+            # Single transcribed word -> multiple reference words
+            words_per_gap = len(reference_words) / len(gap.words)
+
+            for i, orig_word in enumerate(gap.words):
+                start_idx = int(i * words_per_gap)
+                end_idx = int((i + 1) * words_per_gap)
+                ref_words_original_for_orig = reference_words_original[start_idx:end_idx]
+
+                corrections.extend(
+                    WordOperations.create_word_split_corrections(
+                        original_word=orig_word,
+                        reference_words=ref_words_original_for_orig,
+                        original_position=gap.transcription_position + i,
+                        source=matching_source,
+                        confidence=0.8,
+                        reason="SyllablesMatchHandler: Split word based on syllable match",
+                        reference_positions=reference_positions,
+                    )
+                )
+
+        else:
+            # One-to-one replacement
+            for i, (orig_word, ref_word, ref_word_original) in enumerate(zip(gap.words, reference_words, reference_words_original)):
+                if orig_word.lower() != ref_word.lower():
+                    corrections.append(
+                        WordOperations.create_word_replacement_correction(
+                            original_word=orig_word,
+                            corrected_word=ref_word_original,
+                            original_position=gap.transcription_position + i,
+                            source=matching_source,
+                            confidence=0.8,
+                            reason=f"SyllablesMatchHandler: Source '{matching_source}' had matching syllable count",
+                            reference_positions=reference_positions,
+                        )
+                    )
+
+        return corrections

lyrics_transcriber/correction/handlers/word_count_match.py

@@ -0,0 +1,54 @@
+from typing import List, Tuple, Dict, Any, Optional
+
+from lyrics_transcriber.types import GapSequence, WordCorrection
+from lyrics_transcriber.correction.handlers.base import GapCorrectionHandler
+from lyrics_transcriber.correction.handlers.word_operations import WordOperations
+
+
+class WordCountMatchHandler(GapCorrectionHandler):
+    """Handles gaps where reference sources agree and have matching word counts."""
+
+    def can_handle(self, gap: GapSequence) -> Tuple[bool, Dict[str, Any]]:
+        # Must have reference words
+        if not gap.reference_words:
+            return False, {}
+
+        ref_words_lists = list(gap.reference_words.values())
+
+        # All sources must have same number of words as gap
+        if not all(len(words) == gap.length for words in ref_words_lists):
+            return False, {}
+
+        # If we have multiple sources, they must all agree
+        if len(ref_words_lists) > 1 and not all(words == ref_words_lists[0] for words in ref_words_lists[1:]):
+            return False, {}
+
+        return True, {}
+
+    def handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> List[WordCorrection]:
+        corrections = []
+        # Get both clean and original reference words from first source
+        source = list(gap.reference_words.keys())[0]
+        reference_words = gap.reference_words[source]
+        reference_words_original = gap.reference_words_original[source]
+        sources = ", ".join(gap.reference_words.keys())
+
+        # Use the centralized method to calculate reference positions for all sources
+        reference_positions = WordOperations.calculate_reference_positions(gap)
+
+        # Since we know all reference sources agree, we can correct all words in the gap
+        for i, (orig_word, ref_word, ref_word_original) in enumerate(zip(gap.words, reference_words, reference_words_original)):
+            if orig_word.lower() != ref_word.lower():
+                corrections.append(
+                    WordOperations.create_word_replacement_correction(
+                        original_word=orig_word,
+                        corrected_word=ref_word_original,
+                        original_position=gap.transcription_position + i,
+                        source=sources,
+                        confidence=1.0,
+                        reason="WordCountMatchHandler: Reference sources had same word count as gap",
+                        reference_positions=reference_positions,
+                    )
+                )
+
+        return corrections