karaoke-gen 0.57.0__py3-none-any.whl → 0.71.27__py3-none-any.whl

lyrics_transcriber/correction/handlers/no_space_punct_match.py

@@ -0,0 +1,154 @@
+from typing import List, Optional, Tuple, Dict, Any
+import logging
+import re
+
+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 NoSpacePunctuationMatchHandler(GapCorrectionHandler):
+    """Handles gaps where reference text matches when spaces and punctuation are removed."""
+
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        super().__init__(logger)
+        self.logger = logger or logging.getLogger(__name__)
+
+    def _remove_spaces_and_punct(self, words: List[str]) -> str:
+        """Join words and remove all whitespace and punctuation."""
+        text = "".join(words).lower()
+        # Remove all punctuation including apostrophes
+        return re.sub(r"[^\w\s]", "", text)
+
+    def can_handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> Tuple[bool, Dict[str, Any]]:
+        # Must have reference words
+        if not gap.reference_word_ids:
+            self.logger.debug("No reference word IDs available.")
+            return False, {}
+
+        # Get word lookup map from data
+        if not data or "word_map" not in data:
+            self.logger.error("No word_map provided in data")
+            return False, {}
+
+        word_map = data["word_map"]
+
+        # Get the actual words from word IDs
+        gap_words = []
+        for word_id in gap.transcribed_word_ids:
+            if word_id not in word_map:
+                self.logger.error(f"Word ID {word_id} not found in word_map")
+                return False, {}
+            gap_words.append(word_map[word_id].text)
+
+        # Get the gap text without spaces and punctuation
+        gap_text = self._remove_spaces_and_punct(gap_words)
+
+        # Check if any reference source matches when spaces and punctuation are removed
+        for source, ref_word_ids in gap.reference_word_ids.items():
+            ref_words = []
+            for word_id in ref_word_ids:
+                if word_id not in word_map:
+                    self.logger.error(f"Reference word ID {word_id} not found in word_map")
+                    continue
+                ref_words.append(word_map[word_id].text)
+
+            if not ref_words:
+                continue
+
+            ref_text = self._remove_spaces_and_punct(ref_words)
+            if gap_text == ref_text:
+                self.logger.debug("Found a matching reference source with spaces and punctuation removed.")
+                return True, {
+                    "matching_source": source,
+                    "reference_word_ids": ref_word_ids,
+                    "word_map": word_map,
+                }
+
+        self.logger.debug("No matching reference source found with spaces and punctuation removed.")
+        return False, {}
+
+    def handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> List[WordCorrection]:
+        """Handle the gap using no-space punctuation matching."""
+        if not data:
+            can_handle, data = self.can_handle(gap)
+            if not can_handle:
+                return []
+
+        corrections = []
+        matching_source = data["matching_source"]
+        reference_word_ids = data["reference_word_ids"]
+        word_map = data["word_map"]
+
+        # Calculate reference positions for the matching source
+        reference_positions = WordOperations.calculate_reference_positions(gap, [matching_source])
+
+        # Handle cases where number of words differ
+        if len(gap.transcribed_word_ids) > len(reference_word_ids):
+            # Multiple transcribed words -> fewer reference words
+            # Get the actual words from word IDs
+            gap_words = [word_map[word_id].text for word_id in gap.transcribed_word_ids]
+            ref_word = word_map[reference_word_ids[0]].text
+
+            corrections.extend(
+                WordOperations.create_word_combine_corrections(
+                    original_words=gap_words,
+                    reference_word=ref_word,
+                    original_position=gap.transcription_position,
+                    source=matching_source,
+                    confidence=1.0,
+                    combine_reason="Words combined based on text match",
+                    delete_reason="Word removed as part of text match combination",
+                    reference_positions=reference_positions,
+                    handler="NoSpacePunctuationMatchHandler",
+                    original_word_ids=gap.transcribed_word_ids,
+                    corrected_word_id=reference_word_ids[0],  # Use the reference word's ID
+                )
+            )
+            self.logger.debug(f"Combined words into '{ref_word}'.")
+
+        elif len(gap.transcribed_word_ids) < len(reference_word_ids):
+            # Single transcribed word -> multiple reference words
+            # Get the actual words
+            gap_word = word_map[gap.transcribed_word_ids[0]].text
+            ref_words = [word_map[word_id].text for word_id in reference_word_ids]
+
+            corrections.extend(
+                WordOperations.create_word_split_corrections(
+                    original_word=gap_word,
+                    reference_words=ref_words,
+                    original_position=gap.transcription_position,
+                    source=matching_source,
+                    confidence=1.0,
+                    reason="Split word based on text match",
+                    reference_positions=reference_positions,
+                    handler="NoSpacePunctuationMatchHandler",
+                    original_word_id=gap.transcribed_word_ids[0],
+                    corrected_word_ids=reference_word_ids,  # Use the reference word IDs
+                )
+            )
+            self.logger.debug(f"Split word '{gap_word}' into {ref_words}.")
+
+        else:
+            # One-to-one replacement
+            for i, (orig_word_id, ref_word_id) in enumerate(zip(gap.transcribed_word_ids, reference_word_ids)):
+                orig_word = word_map[orig_word_id]
+                ref_word = word_map[ref_word_id]
+
+                if orig_word.text.lower() != ref_word.text.lower():
+                    correction = WordOperations.create_word_replacement_correction(
+                        original_word=orig_word.text,
+                        corrected_word=ref_word.text,
+                        original_position=gap.transcription_position + i,
+                        source=matching_source,
+                        confidence=1.0,
+                        reason=f"Source '{matching_source}' matched when spaces and punctuation removed",
+                        reference_positions=reference_positions,
+                        handler="NoSpacePunctuationMatchHandler",
+                        original_word_id=orig_word_id,
+                        corrected_word_id=ref_word_id,
+                    )
+                    corrections.append(correction)
+                    self.logger.debug(f"Correction made: {correction}")
+
+        return corrections

lyrics_transcriber/correction/handlers/relaxed_word_count_match.py

@@ -0,0 +1,85 @@
+from typing import List, Tuple, Dict, Any, Optional
+import logging
+
+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 __init__(self, logger: Optional[logging.Logger] = None):
+        super().__init__(logger)
+        self.logger = logger or logging.getLogger(__name__)
+
+    def can_handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> Tuple[bool, Dict[str, Any]]:
+        # Must have reference words
+        if not gap.reference_word_ids:
+            self.logger.debug("No reference word IDs available.")
+            return False, {}
+
+        if not self._validate_data(data):
+            return False, {}
+
+        # Check if any source has matching word count
+        for source, ref_word_ids in gap.reference_word_ids.items():
+            if len(ref_word_ids) == gap.length:
+                self.logger.debug(f"Source '{source}' has matching word count.")
+                return True, {
+                    "matching_source": source,
+                    "reference_word_ids": ref_word_ids,
+                    "word_map": data["word_map"],
+                    "anchor_sequences": data.get("anchor_sequences", []),
+                }
+
+        self.logger.debug("No source with matching word count found.")
+        return False, {}
+
+    def handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> List[WordCorrection]:
+        """Handle the gap using word count matching."""
+        if not self._validate_data(data):
+            return []
+
+        corrections = []
+        matching_source = data["matching_source"]
+        reference_word_ids = data["reference_word_ids"]
+        word_map = data["word_map"]
+        anchor_sequences = data.get("anchor_sequences", [])
+
+        # Use the centralized method to calculate reference positions
+        reference_positions = WordOperations.calculate_reference_positions(
+            gap, sources=[matching_source], anchor_sequences=anchor_sequences
+        )
+        self.logger.debug(f"Calculated reference positions: {reference_positions}")
+
+        # Since we found a source with matching word count, we can correct using that source
+        for i, (orig_word_id, ref_word_id) in enumerate(zip(gap.transcribed_word_ids, reference_word_ids)):
+            # Get the actual words from the word map
+            if orig_word_id not in word_map:
+                self.logger.error(f"Original word ID {orig_word_id} not found in word_map")
+                continue
+            orig_word = word_map[orig_word_id]
+
+            if ref_word_id not in word_map:
+                self.logger.error(f"Reference word ID {ref_word_id} not found in word_map")
+                continue
+            ref_word = word_map[ref_word_id]
+
+            if orig_word.text.lower() != ref_word.text.lower():
+                correction = WordOperations.create_word_replacement_correction(
+                    original_word=orig_word.text,
+                    corrected_word=ref_word.text,
+                    original_position=gap.transcription_position + i,
+                    source=matching_source,
+                    confidence=1.0,
+                    reason=f"Source '{matching_source}' had matching word count",
+                    reference_positions=reference_positions,
+                    handler="RelaxedWordCountMatchHandler",
+                    original_word_id=orig_word_id,
+                    corrected_word_id=ref_word_id,  # Use the reference word's ID
+                )
+                corrections.append(correction)
+                self.logger.debug(f"Correction made: {correction}")
+
+        return corrections

lyrics_transcriber/correction/handlers/repeat.py

@@ -0,0 +1,88 @@
+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):
+        super().__init__(logger)
+        self.logger = logger or logging.getLogger(__name__)
+        self.confidence_threshold = confidence_threshold
+        self.previous_corrections: List[WordCorrection] = []
+
+    def can_handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> Tuple[bool, Dict[str, Any]]:
+        """Check if any words in the gap match previous corrections."""
+        if not self._validate_data(data):
+            return False, {}
+
+        return bool(self.previous_corrections), {"word_map": data["word_map"], "anchor_sequences": data.get("anchor_sequences", [])}
+
+    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."""
+        if not self._validate_data(data):
+            return []
+
+        word_map = data["word_map"]
+        corrections = []
+
+        # Use the centralized method to calculate reference positions
+        reference_positions = WordOperations.calculate_reference_positions(gap, anchor_sequences=data.get("anchor_sequences", []))
+
+        # 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_id in enumerate(gap.transcribed_word_ids):
+            if word_id not in word_map:
+                self.logger.error(f"Word ID {word_id} not found in word map")
+                continue
+
+            word = word_map[word_id]
+            word_lower = word.text.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.text} -> {best_correction.corrected_word} "
+                    f"(confidence: {best_correction.confidence:.2f})"
+                )
+
+                corrections.append(
+                    WordCorrection(
+                        original_word=word.text,
+                        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,
+                        length=best_correction.length,
+                        split_index=best_correction.split_index,
+                        split_total=best_correction.split_total,
+                        handler="RepeatCorrectionHandler",
+                        word_id=word_id,
+                        corrected_word_id=best_correction.corrected_word_id,
+                    )
+                )
+
+        return corrections

lyrics_transcriber/correction/handlers/sound_alike.py

@@ -0,0 +1,259 @@
+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, data: Optional[Dict[str, Any]] = None) -> Tuple[bool, Dict[str, Any]]:
+        """Check if any gap word has a metaphone match with any reference word."""
+        if not self._validate_data(data):
+            return False, {}
+
+        word_map = data["word_map"]
+
+        # Must have reference words
+        if not gap.reference_word_ids:
+            self.logger.debug("No reference words available")
+            return False, {}
+
+        # Gap must have words
+        if not gap.transcribed_word_ids:
+            self.logger.debug("No gap words available")
+            return False, {}
+
+        # Check if any gap word has a metaphone match with any reference word
+        for word_id in gap.transcribed_word_ids:
+            if word_id not in word_map:
+                continue
+            word = word_map[word_id]
+            word_codes = doublemetaphone(word.text)
+            self.logger.debug(f"Gap word '{word.text}' has metaphone codes: {word_codes}")
+
+            for source, ref_word_ids in gap.reference_word_ids.items():
+                for ref_word_id in ref_word_ids:
+                    if ref_word_id not in word_map:
+                        continue
+                    ref_word = word_map[ref_word_id]
+                    ref_codes = doublemetaphone(ref_word.text)
+                    self.logger.debug(f"Reference word '{ref_word.text}' has metaphone codes: {ref_codes}")
+                    if self._codes_match(word_codes, ref_codes):
+                        self.logger.debug(f"Found metaphone match between '{word.text}' and '{ref_word.text}'")
+                        return True, {}
+
+        self.logger.debug("No metaphone matches found")
+        return False, {}
+
+    def handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> List[WordCorrection]:
+        """Process the gap and create corrections for sound-alike matches."""
+        if not self._validate_data(data):
+            return []
+
+        word_map = data["word_map"]
+        corrections = []
+
+        # Use the centralized method to calculate reference positions
+        reference_positions = WordOperations.calculate_reference_positions(gap, anchor_sequences=data.get("anchor_sequences", []))
+
+        # For each word in the gap
+        for i, word_id in enumerate(gap.transcribed_word_ids):
+            if word_id not in word_map:
+                continue
+            word = word_map[word_id]
+            word_codes = doublemetaphone(word.text)
+            self.logger.debug(f"Processing '{word.text}' (codes: {word_codes})")
+
+            # Skip if word exactly matches any reference
+            exact_match = False
+            for source, ref_word_ids in gap.reference_word_ids.items():
+                if i < len(ref_word_ids):
+                    ref_word_id = ref_word_ids[i]
+                    if ref_word_id in word_map:
+                        ref_word = word_map[ref_word_id]
+                        if word.text.lower() == ref_word.text.lower():
+                            exact_match = True
+                            break
+            if exact_match:
+                continue
+
+            # Find sound-alike matches in references
+            matches: Dict[str, Tuple[List[str], float, str]] = {}  # Added word_id to tuple
+
+            for source, ref_word_ids in gap.reference_word_ids.items():
+                for j, ref_word_id in enumerate(ref_word_ids):
+                    if ref_word_id not in word_map:
+                        continue
+                    ref_word = word_map[ref_word_id]
+                    ref_codes = doublemetaphone(ref_word.text)
+
+                    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.text not in matches:
+                                matches[ref_word.text] = ([], adjusted_confidence, ref_word_id)
+                            matches[ref_word.text][0].append(source)
+
+            # Create correction for best match if any found
+            if matches:
+                best_match, (sources, base_confidence, ref_word_id) = max(matches.items(), key=lambda x: (len(x[1][0]), x[1][1]))
+
+                source_confidence = len(sources) / len(gap.reference_word_ids)
+                final_confidence = base_confidence * source_confidence
+
+                self.logger.debug(f"Found match: {word.text} -> {best_match} " f"(confidence: {final_confidence:.2f}, sources: {sources})")
+
+                corrections.append(
+                    WordCorrection(
+                        original_word=word.text,
+                        corrected_word=best_match,
+                        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,
+                        length=1,
+                        handler="SoundAlikeHandler",
+                        word_id=word_id,
+                        corrected_word_id=ref_word_id,
+                    )
+                )
+
+        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