lyrics-transcriber 0.30.1__py3-none-any.whl → 0.32.2__py3-none-any.whl

lyrics_transcriber/types.py

@@ -0,0 +1,454 @@
+from dataclasses import dataclass, asdict, field
+from typing import Any, Dict, List, Optional, Set, Protocol, Tuple
+from enum import Enum
+
+
+@dataclass
+class Word:
+    """Represents a single word with its timing (in seconds) and confidence information."""
+
+    text: str
+    start_time: float
+    end_time: float
+    confidence: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert Word to dictionary for JSON serialization."""
+        d = asdict(self)
+        # Remove confidence from output if it's None
+        if d["confidence"] is None:
+            del d["confidence"]
+        return d
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Word":
+        """Create Word from dictionary."""
+        return cls(
+            text=data["text"],
+            start_time=data["start_time"],
+            end_time=data["end_time"],
+            confidence=data.get("confidence"),  # Use get() since confidence is optional
+        )
+
+
+@dataclass
+class LyricsSegment:
+    """Represents a segment/line of lyrics with timing information in seconds."""
+
+    text: str
+    words: List[Word]
+    start_time: float
+    end_time: float
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert LyricsSegment to dictionary for JSON serialization."""
+        return {
+            "text": self.text,
+            "words": [word.to_dict() for word in self.words],
+            "start_time": self.start_time,
+            "end_time": self.end_time,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "LyricsSegment":
+        """Create LyricsSegment from dictionary."""
+        return cls(
+            text=data["text"],
+            words=[Word.from_dict(w) for w in data["words"]],
+            start_time=data["start_time"],
+            end_time=data["end_time"],
+        )
+
+
+@dataclass
+class LyricsMetadata:
+    """Standardized metadata for lyrics results."""
+
+    source: str
+    track_name: str
+    artist_names: str
+
+    # Common metadata fields
+    album_name: Optional[str] = None
+    duration_ms: Optional[int] = None
+    explicit: Optional[bool] = None
+    language: Optional[str] = None
+    is_synced: bool = False
+
+    # Lyrics provider details
+    lyrics_provider: Optional[str] = None
+    lyrics_provider_id: Optional[str] = None
+
+    # Provider-specific metadata
+    provider_metadata: Dict[str, Any] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert metadata to dictionary for JSON serialization."""
+        return asdict(self)
+
+
+@dataclass
+class LyricsData:
+    """Standardized response format for all lyrics providers."""
+
+    lyrics: str
+    segments: List[LyricsSegment]
+    metadata: LyricsMetadata
+    source: str  # e.g., "genius", "spotify", etc.
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary for JSON serialization."""
+        return {
+            "lyrics": self.lyrics,
+            "segments": [segment.to_dict() for segment in self.segments],
+            "metadata": self.metadata.to_dict(),
+            "source": self.source,
+        }
+
+
+@dataclass
+class WordCorrection:
+    """Details about a single word correction."""
+
+    original_word: str
+    corrected_word: str  # Empty string indicates word should be deleted
+    segment_index: int
+    original_position: int
+    source: str  # e.g., "spotify", "genius"
+    confidence: Optional[float]
+    reason: str  # e.g., "matched_in_3_sources", "high_confidence_match"
+    alternatives: Dict[str, int]  # Other possible corrections and their occurrence counts
+    is_deletion: bool = False  # New field to explicitly mark deletions
+    # New fields for handling word splits
+    split_index: Optional[int] = None  # Position in the split sequence (0-based)
+    split_total: Optional[int] = None  # Total number of words in split
+    # New field to track position after corrections
+    corrected_position: Optional[int] = None
+    # New fields to match TypeScript interface
+    reference_positions: Optional[Dict[str, int]] = None  # Maps source to position in reference text
+    length: int = 1  # Default to 1 for single-word corrections
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "WordCorrection":
+        """Create WordCorrection from dictionary."""
+        return cls(**data)
+
+
+@dataclass
+class TranscriptionData:
+    """Structured container for transcription results."""
+
+    segments: List[LyricsSegment]
+    words: List[Word]
+    text: str
+    source: str  # e.g., "whisper", "audioshake"
+    metadata: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert TranscriptionData to dictionary for JSON serialization."""
+        return {
+            "segments": [segment.to_dict() for segment in self.segments],
+            "words": [word.to_dict() for word in self.words],
+            "text": self.text,
+            "source": self.source,
+            "metadata": self.metadata,
+        }
+
+
+@dataclass
+class TranscriptionResult:
+    name: str
+    priority: int
+    result: TranscriptionData
+
+
+class PhraseType(Enum):
+    """Types of phrases we can identify"""
+
+    COMPLETE = "complete"  # Grammatically complete unit
+    PARTIAL = "partial"  # Incomplete but valid fragment
+    CROSS_BOUNDARY = "cross"  # Crosses natural boundaries
+
+
+@dataclass
+class PhraseScore:
+    """Scores for a potential phrase"""
+
+    phrase_type: PhraseType
+    natural_break_score: float  # 0-1, how well it respects natural breaks
+    length_score: float  # 0-1, how appropriate the length is
+
+    @property
+    def total_score(self) -> float:
+        """Calculate total score with weights"""
+        weights = {PhraseType.COMPLETE: 1.0, PhraseType.PARTIAL: 0.7, PhraseType.CROSS_BOUNDARY: 0.3}
+        return weights[self.phrase_type] * 0.5 + self.natural_break_score * 0.3 + self.length_score * 0.2
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert PhraseScore to dictionary for JSON serialization."""
+        return {
+            "phrase_type": self.phrase_type.value,  # Convert enum to value for JSON
+            "natural_break_score": self.natural_break_score,
+            "length_score": self.length_score,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "PhraseScore":
+        """Create PhraseScore from dictionary."""
+        return cls(
+            phrase_type=PhraseType(data["phrase_type"]), natural_break_score=data["natural_break_score"], length_score=data["length_score"]
+        )
+
+
+@dataclass
+class AnchorSequence:
+    """Represents a sequence of words that appears in both transcribed and reference lyrics."""
+
+    words: List[str]
+    transcription_position: int  # Starting position in transcribed text
+    reference_positions: Dict[str, int]  # Source -> position mapping
+    confidence: float
+
+    @property
+    def text(self) -> str:
+        """Get the sequence as a space-separated string."""
+        return " ".join(self.words)
+
+    @property
+    def length(self) -> int:
+        """Get the number of words in the sequence."""
+        return len(self.words)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the anchor sequence to a JSON-serializable dictionary."""
+        return {
+            "words": self.words,
+            "text": self.text,
+            "length": self.length,
+            "transcription_position": self.transcription_position,
+            "reference_positions": self.reference_positions,
+            "confidence": self.confidence,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AnchorSequence":
+        """Create AnchorSequence from dictionary."""
+        return cls(
+            words=data["words"],
+            transcription_position=data["transcription_position"],
+            reference_positions=data["reference_positions"],
+            confidence=data["confidence"],
+        )
+
+
+@dataclass
+class ScoredAnchor:
+    """An anchor sequence with its quality score"""
+
+    anchor: AnchorSequence
+    phrase_score: PhraseScore
+
+    @property
+    def total_score(self) -> float:
+        """Combine confidence, phrase quality, and length"""
+        # Length bonus: (length - 1) * 0.1 gives 0.1 per extra word
+        length_bonus = (self.anchor.length - 1) * 0.1
+        # Base score heavily weighted towards confidence
+        base_score = self.anchor.confidence * 0.8 + self.phrase_score.total_score * 0.2
+        # Combine scores
+        return base_score + length_bonus
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the scored anchor to a JSON-serializable dictionary."""
+        return {
+            **self.anchor.to_dict(),
+            "phrase_score": {
+                "phrase_type": self.phrase_score.phrase_type.value,
+                "natural_break_score": self.phrase_score.natural_break_score,
+                "length_score": self.phrase_score.length_score,
+                "total_score": self.phrase_score.total_score,
+            },
+            "total_score": self.total_score,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ScoredAnchor":
+        """Create ScoredAnchor from dictionary."""
+        return cls(anchor=AnchorSequence.from_dict(data["anchor"]), phrase_score=PhraseScore.from_dict(data["phrase_score"]))
+
+
+@dataclass
+class GapSequence:
+    """Represents a sequence of words between anchor sequences in transcribed lyrics."""
+
+    words: Tuple[str, ...]
+    transcription_position: int  # Original starting position in transcription
+    preceding_anchor: Optional[AnchorSequence]
+    following_anchor: Optional[AnchorSequence]
+    reference_words: Dict[str, List[str]]
+    reference_words_original: Dict[str, List[str]]
+    corrections: List[WordCorrection] = field(default_factory=list)
+    _corrected_positions: Set[int] = field(default_factory=set, repr=False)
+    _position_offset: int = field(default=0, repr=False)  # Track cumulative position changes
+
+    def add_correction(self, correction: WordCorrection) -> None:
+        """Add a correction and mark its position as corrected."""
+        self.corrections.append(correction)
+        relative_pos = correction.original_position - self.transcription_position
+        self._corrected_positions.add(relative_pos)
+
+        # Update position offset based on correction type
+        if correction.is_deletion:
+            self._position_offset -= 1
+        elif correction.split_total:
+            self._position_offset += correction.split_total - 1
+
+        # Update corrected position for the correction
+        correction.corrected_position = correction.original_position + self._position_offset
+
+    def get_corrected_position(self, original_position: int) -> int:
+        """Convert an original position to its corrected position."""
+        offset = sum(
+            -1 if c.is_deletion else (c.split_total - 1 if c.split_total else 0)
+            for c in self.corrections
+            if c.original_position < original_position
+        )
+        return original_position + offset
+
+    @property
+    def corrected_length(self) -> int:
+        """Get the length after applying all corrections."""
+        return self.length + self._position_offset
+
+    def is_word_corrected(self, relative_position: int) -> bool:
+        """Check if a word at the given position (relative to gap start) has been corrected."""
+        return relative_position in self._corrected_positions
+
+    @property
+    def uncorrected_words(self) -> List[Tuple[int, str]]:
+        """Get list of (position, word) tuples for words that haven't been corrected yet."""
+        return [(i, word) for i, word in enumerate(self.words) if i not in self._corrected_positions]
+
+    @property
+    def is_fully_corrected(self) -> bool:
+        """Check if all words in the gap have been corrected."""
+        return len(self._corrected_positions) == self.length
+
+    def __hash__(self):
+        # Hash based on words and position
+        return hash((self.words, self.transcription_position))
+
+    def __eq__(self, other):
+        if not isinstance(other, GapSequence):
+            return NotImplemented
+        return self.words == other.words and self.transcription_position == other.transcription_position
+
+    @property
+    def text(self) -> str:
+        """Get the sequence as a space-separated string."""
+        return " ".join(self.words)
+
+    @property
+    def length(self) -> int:
+        """Get the number of words in the sequence."""
+        return len(self.words)
+
+    @property
+    def was_corrected(self) -> bool:
+        """Check if this gap has any corrections."""
+        return len(self.corrections) > 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the gap sequence to a JSON-serializable dictionary."""
+        return {
+            "words": self.words,
+            "text": self.text,
+            "length": self.length,
+            "transcription_position": self.transcription_position,
+            "preceding_anchor": self.preceding_anchor.to_dict() if self.preceding_anchor else None,
+            "following_anchor": self.following_anchor.to_dict() if self.following_anchor else None,
+            "reference_words": self.reference_words,
+            "reference_words_original": self.reference_words_original,
+            "corrections": [c.to_dict() for c in self.corrections],
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GapSequence":
+        """Create GapSequence from dictionary."""
+        gap = cls(
+            words=tuple(data["words"]),
+            transcription_position=data["transcription_position"],
+            preceding_anchor=AnchorSequence.from_dict(data["preceding_anchor"]) if data["preceding_anchor"] else None,
+            following_anchor=AnchorSequence.from_dict(data["following_anchor"]) if data["following_anchor"] else None,
+            reference_words=data["reference_words"],
+            reference_words_original=data.get("reference_words_original", {}),
+        )
+        # Add any corrections from the data
+        if "corrections" in data:
+            for correction_data in data["corrections"]:
+                gap.add_correction(WordCorrection.from_dict(correction_data))
+        return gap
+
+
+@dataclass
+class CorrectionResult:
+    """Container for correction results with detailed correction information."""
+
+    # Original (uncorrected) data
+    original_segments: List[LyricsSegment]
+
+    # Corrected data
+    corrected_segments: List[LyricsSegment]
+    corrected_text: str
+
+    # Correction details
+    corrections: List[WordCorrection]
+    corrections_made: int
+    confidence: float
+
+    # Debug/analysis information
+    transcribed_text: str
+    reference_texts: Dict[str, str]
+    anchor_sequences: List[AnchorSequence]
+    gap_sequences: List[GapSequence]
+    resized_segments: List[LyricsSegment]
+
+    metadata: Dict[str, Any]
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the correction result to a JSON-serializable dictionary."""
+        return {
+            "transcribed_text": self.transcribed_text,
+            "original_segments": [s.to_dict() for s in self.original_segments],
+            "reference_texts": self.reference_texts,
+            "anchor_sequences": [a.to_dict() for a in self.anchor_sequences],
+            "gap_sequences": [g.to_dict() for g in self.gap_sequences],
+            "resized_segments": [s.to_dict() for s in self.resized_segments],
+            "corrected_text": self.corrected_text,
+            "corrections_made": self.corrections_made,
+            "confidence": self.confidence,
+            "corrections": [c.to_dict() for c in self.corrections],
+            "corrected_segments": [s.to_dict() for s in self.corrected_segments],
+            "metadata": self.metadata,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "CorrectionResult":
+        """Create CorrectionResult from dictionary."""
+        return cls(
+            original_segments=[LyricsSegment.from_dict(s) for s in data["original_segments"]],
+            corrected_segments=[LyricsSegment.from_dict(s) for s in data["corrected_segments"]],
+            corrected_text=data["corrected_text"],
+            corrections=[WordCorrection.from_dict(c) for c in data["corrections"]],
+            corrections_made=data["corrections_made"],
+            confidence=data["confidence"],
+            transcribed_text=data["transcribed_text"],
+            reference_texts=data["reference_texts"],
+            anchor_sequences=[AnchorSequence.from_dict(a) for a in data["anchor_sequences"]],
+            gap_sequences=[GapSequence.from_dict(g) for g in data["gap_sequences"]],
+            resized_segments=[LyricsSegment.from_dict(s) for s in data["resized_segments"]],
+            metadata=data["metadata"],
+        )

{lyrics_transcriber-0.30.1.dist-info → lyrics_transcriber-0.32.2.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lyrics-transcriber
-Version: 0.30.1
+Version: 0.32.2
 Summary: Automatically create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps, using Whisper and lyrics from Genius and Spotify
-Home-page: https://github.com/karaokenerds/python-lyrics-transcriber
 License: MIT
 Author: Andrew Beveridge
 Author-email: andrew@beveridge.uk
@@ -14,13 +13,25 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: dropbox (>=12)
+Requires-Dist: fastapi (>=0.115)
 Requires-Dist: karaoke-lyrics-processor (>=0.4)
 Requires-Dist: lyricsgenius (>=3)
+Requires-Dist: metaphone (>=0.6)
+Requires-Dist: nltk (>=3.9)
 Requires-Dist: pydub (>=0.25)
 Requires-Dist: python-dotenv (>=1)
+Requires-Dist: python-levenshtein (>=0.26)
 Requires-Dist: python-slugify (>=8)
+Requires-Dist: spacy (>=3.8)
+Requires-Dist: spacy-syllables (>=3)
+Requires-Dist: syllables (>=1)
 Requires-Dist: syrics (>=0)
+Requires-Dist: torch (>=2)
+Requires-Dist: tqdm (>=4.67)
+Requires-Dist: transformers (>=4.47)
+Requires-Dist: uvicorn (>=0.34)
 Project-URL: Documentation, https://github.com/karaokenerds/python-lyrics-transcriber/blob/main/README.md
+Project-URL: Homepage, https://github.com/karaokenerds/python-lyrics-transcriber
 Project-URL: Repository, https://github.com/karaokenerds/python-lyrics-transcriber
 Description-Content-Type: text/markdown
 

lyrics_transcriber-0.32.2.dist-info/RECORD

@@ -0,0 +1,86 @@
+lyrics_transcriber/__init__.py,sha256=JpdjDK1MH_Be2XiSQWnb4i5Bbil1uPMA_KcuDZ3cyUI,240
+lyrics_transcriber/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/cli/cli_main.py,sha256=pquvPfhw6brNgUyMuAzXfCUXNN0NM5tP_MyxlLWqNPc,8968
+lyrics_transcriber/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/core/config.py,sha256=eddocVn_VoBGRqgBzfSvO7EZp3NuoGfSmd6mcT8wa74,941
+lyrics_transcriber/core/controller.py,sha256=eQ0M67SWIA-hr23fkw6F8hmqKkklOHsxOsJnYQLXFBE,12184
+lyrics_transcriber/correction/anchor_sequence.py,sha256=YpKyY24Va5i4JgzP9ssqlOIkaYu060KaldiehbfgTdk,22200
+lyrics_transcriber/correction/corrector.py,sha256=VOM6YhbANu00rYs6JpKHGZXnZtD5fxArnYtRrsp1YM4,12998
+lyrics_transcriber/correction/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/correction/handlers/base.py,sha256=Vanmp6ykP5cdejuJ5ttzjP0Wl4JgKBL-mHbo9EFaeVc,1009
+lyrics_transcriber/correction/handlers/extend_anchor.py,sha256=9rBrZPmc4grMSnCL2ilkcBsWHc05s6RBL9GDyNAplJk,3821
+lyrics_transcriber/correction/handlers/levenshtein.py,sha256=pe62eyDE3XxLC219rvtvvfd_lna1q0SuiGcYBYX-nwM,6425
+lyrics_transcriber/correction/handlers/no_space_punct_match.py,sha256=ri4QEdkYssUC3q0SMGiToYnw4MboRp5i3WGOh9zj3Zw,4573
+lyrics_transcriber/correction/handlers/relaxed_word_count_match.py,sha256=Y_4S8orGx1LQzlr2yCrGYkvtVLzjD31urtW9tkbwado,2474
+lyrics_transcriber/correction/handlers/repeat.py,sha256=jeUwpgU3no1Stk7bOHweDfIOxM2xsykbttdnsD-e_Rg,3682
+lyrics_transcriber/correction/handlers/sound_alike.py,sha256=mAmnpRpO29rHaP96V-U3QTS1aOM32IV2YUYgS0y9ibo,10635
+lyrics_transcriber/correction/handlers/syllables_match.py,sha256=5M7-0A6G-eu4nyzxT0wiuUpN5zbqXq9d-zeTP7AdLfg,8377
+lyrics_transcriber/correction/handlers/word_count_match.py,sha256=zbyZ01VE_6azaFpi8rS0Ato7c_VBxM2KV83VnDH5t3c,2522
+lyrics_transcriber/correction/handlers/word_operations.py,sha256=2COTaJsEwpSWyXHXmGgjfcf2x7tbAnsQ0dIW0qyHYK4,5141
+lyrics_transcriber/correction/phrase_analyzer.py,sha256=D94Ytlo7U2eTHYJ_nCVLhafmtTYExKx6v2_aczOJaQ8,16455
+lyrics_transcriber/correction/text_utils.py,sha256=VkOqgZHa9wEqLJdVNi4-KLFojQ6d4lWOGl_Y_vknenU,808
+lyrics_transcriber/lyrics/base_lyrics_provider.py,sha256=i4wxzu8nk2a3NDtnB_4r6rOGBZ7WvJFVlcEBjAkUYgI,5511
+lyrics_transcriber/lyrics/genius.py,sha256=M4rs3yk5RKW-RYfMm9w-UxwKQ8itgYeM-kVS6LCn8D0,3295
+lyrics_transcriber/lyrics/spotify.py,sha256=9n4n98xS_BrpTPZg-24n0mzyPk9vkdmhy6T8ei8imh4,3599
+lyrics_transcriber/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/output/ass/__init__.py,sha256=EYQ45gI7_-vclVgzISL0ML8VgxCdB0odqEyPyiPCIw0,578
+lyrics_transcriber/output/ass/ass.py,sha256=xHId7Rv5gqmdQ7ZrWQSy46JX7vZcB_BzpZC800DwQk8,74315
+lyrics_transcriber/output/ass/ass_specs.txt,sha256=r80HVXWSjTMGU7o2NOJdHkYNBY6SVwSVf0Dyslc1OXk,39288
+lyrics_transcriber/output/ass/config.py,sha256=VOa9raO88b2QDuHbLvPN_7yqOq-fdBEijwN7S893BCY,1014
+lyrics_transcriber/output/ass/constants.py,sha256=CUxR7K3LnoZeA7WMuMYMAPto0J7VW3IwKlP_Ve7XB0A,536
+lyrics_transcriber/output/ass/event.py,sha256=XVbA7YR6WgFa5ynrgE2R7ngauWZVZyNn86BfyNLF0u8,2657
+lyrics_transcriber/output/ass/formatters.py,sha256=hx_3a1goRIVQwAeNyu9n4UZcnpO9vm87x1aiHK5TBRc,3614
+lyrics_transcriber/output/ass/lyrics_line.py,sha256=WIOhNzBg4b29xL-7qklQzvyfPdWS1_LX_RYa84jz5wc,9480
+lyrics_transcriber/output/ass/lyrics_screen.py,sha256=gRzUsDMLEtZZPuv77xk7M0FzCpFph5tjlE5hhFaobOw,10676
+lyrics_transcriber/output/ass/section_detector.py,sha256=TsSf4E0fleC-Tzd5KK6q4m-wjGiu6TvGDtHdR6sUqvc,3922
+lyrics_transcriber/output/ass/section_screen.py,sha256=QeUaIeDXs_Es33W5aqyVSaZzMwUx-b60vbAww3aQfls,4185
+lyrics_transcriber/output/ass/style.py,sha256=ty3IGorlOZ_Q-TxeA02hNb5Pb0mA755dOb8bqKr1k7U,6880
+lyrics_transcriber/output/cdg.py,sha256=V1T2oBmrCLWhBwLiyCiys3C2W1mDqki54JRKC_TvNIM,20732
+lyrics_transcriber/output/cdgmaker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/output/cdgmaker/cdg.py,sha256=nBqkw0JOois-NI27CkwHblLuBaoL-sHyJb2SntX7m8s,6733
+lyrics_transcriber/output/cdgmaker/composer.py,sha256=qUBlGonxPeCs0G7u2bqIpF58ySAZr9mZxLStWZr9ksY,76193
+lyrics_transcriber/output/cdgmaker/config.py,sha256=dOsOaPg9XawR3sWdTBoQiYn7urQWafV2KzedhI6BHYU,4043
+lyrics_transcriber/output/cdgmaker/images/instrumental.png,sha256=EKUcJJGj95ceNqw7M-O9ltX4HZIaCaSKjJucKVDTSb8,14834
+lyrics_transcriber/output/cdgmaker/images/intro.png,sha256=XeN6i8aKaQObfRwcgHT8ajQAJIDVjXEd7C5tu7DtriU,17603
+lyrics_transcriber/output/cdgmaker/pack.py,sha256=tuD7Udt3fpWiEVRnzO3VarULwmQ21QYE_MYc6XSpudg,15870
+lyrics_transcriber/output/cdgmaker/render.py,sha256=K0BGr4I4BKAMn2tkX3QBtA_CWi7XUi1exP4EwBKxjZs,11028
+lyrics_transcriber/output/cdgmaker/transitions/centertexttoplogobottomtext.png,sha256=GK8AqHHL3q6QGSvhCc51CzeQ-TvQGjYAfjxAgcGzZVw,37174
+lyrics_transcriber/output/cdgmaker/transitions/circlein.png,sha256=jeRXV1Sf9HrN-H710_Xj6nsDk0QS8RGefdaxdD2l4FI,25030
+lyrics_transcriber/output/cdgmaker/transitions/circleout.png,sha256=sQ4YSMiLy78hIuWUgvoWeuvj_OKmLUxD2XLgx5-_DqI,44026
+lyrics_transcriber/output/cdgmaker/transitions/fizzle.png,sha256=8jSvglEwTuurFr07s82uBdx8SLR2yTB65g_NXE55jjU,2588
+lyrics_transcriber/output/cdgmaker/transitions/largecentertexttoplogo.png,sha256=UYap1UDfNMjqQ9S3XoJzReoiwoYYhVeTfnGSvwnIOd4,35912
+lyrics_transcriber/output/cdgmaker/transitions/rectangle.png,sha256=HXX1CqRxbJEhcqT7kiobtYvh2lCbcVaBL0WC2gLDMPw,27969
+lyrics_transcriber/output/cdgmaker/transitions/spiral.png,sha256=zSXl8k208QetD7tJp6kMQVygtREoHvG_wDRi0tfYcus,54261
+lyrics_transcriber/output/cdgmaker/transitions/topleftmusicalnotes.png,sha256=cCpsT49CQD9walZxToBbnQo2unJE5ke57ASkkLDwZaQ,14612
+lyrics_transcriber/output/cdgmaker/transitions/wipein.png,sha256=hWuWt2a89dbgj_aRdvXYuElaxhbJaKJoykd4geOLcII,9880
+lyrics_transcriber/output/cdgmaker/transitions/wipeleft.png,sha256=7jY6Z-mdY94PEy8stm2N0cPB9MPLgmsc_A7eRiERNWc,8613
+lyrics_transcriber/output/cdgmaker/transitions/wipeout.png,sha256=YSLdv2RCGeSilOGt7PYTLAOlBfL4bofu8Vpj-PcskZo,9995
+lyrics_transcriber/output/cdgmaker/transitions/wiperight.png,sha256=Dw3N6cqJaSwL3owDqyAM4W573EmdNnkjdiXhoxWC4yk,8443
+lyrics_transcriber/output/cdgmaker/utils.py,sha256=TNcOnccegpxT3OogWQCexy8BrDqfihLAShMvqeM81cw,2945
+lyrics_transcriber/output/fonts/AvenirNext-Bold.ttf,sha256=YxgKz2OP46lwLPCpIZhVa8COi_9KRDSXw4n8dIHHQSs,327048
+"lyrics_transcriber/output/fonts/DMSans-VariableFont_opsz,wght.ttf",sha256=7uav75vmxRukpMx8wqtPeNvaxqOzlBljO400geBzYYI,238984
+lyrics_transcriber/output/fonts/DMSerifDisplay-Regular.ttf,sha256=mMHMLr3CMjEQgJ5cKlYEn8YSsHwSnDtxT-Qjn_n8ffM,72220
+lyrics_transcriber/output/fonts/Oswald-SemiBold.ttf,sha256=G-vSJeeyEVft7D4s7FZQtGfXAViWPjzGCImV2a4u9d8,87608
+lyrics_transcriber/output/fonts/Zurich_Cn_BT_Bold.ttf,sha256=WNG5LOQ-uGUF_WWT5aQHzVbyWvQqGO5sZ4E-nRmvPuI,37780
+lyrics_transcriber/output/fonts/arial.ttf,sha256=NcDzVZ2NtWnjbDEJW4pg1EFkPZX1kTneQOI_ragZuDM,275572
+lyrics_transcriber/output/fonts/georgia.ttf,sha256=fQuyDGMrtZ6BoIhfVzvSFz9x9zIE3pBY_raM4DIicHI,142964
+lyrics_transcriber/output/fonts/verdana.ttf,sha256=lu0UlJyktzks_yNbnEHVXBJTgqu-DA08K53WaJfK4Ms,139640
+lyrics_transcriber/output/generator.py,sha256=HQa3Ft8SKJie9-cYO0NKDbAU2-h_YnnH5wACxj0qFKw,7482
+lyrics_transcriber/output/lyrics_file.py,sha256=_KQyQjCOMIwQdQ0115uEAUIjQWTRmShkSfQuINPKxaw,3741
+lyrics_transcriber/output/plain_text.py,sha256=3mYKq0BLYz1rGBD6ROjG2dn6BPuzbn5dxIQbWZVi4ao,3689
+lyrics_transcriber/output/segment_resizer.py,sha256=xkKCNt4CTdTErUTYsYtjmllKY8YHny1srqQMrJQYbK8,17141
+lyrics_transcriber/output/subtitles.py,sha256=BQy7N_2zdBBWEiHL0NWFz3ZgAerWqQvTLALgxxK3Etk,16920
+lyrics_transcriber/output/video.py,sha256=kYGeEMYtoJvrGnMuyNpuSmu2DTskGDXBNlrv6ddvC8I,8485
+lyrics_transcriber/review/__init__.py,sha256=_3Eqw-uXZhOZwo6_sHZLhP9vxAVkLF9EBXduUvPdLjQ,57
+lyrics_transcriber/review/server.py,sha256=iAG0WUkGrqnAF7dI4ZQQayp2qaamqGGYT6rWJF9OysI,4397
+lyrics_transcriber/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/storage/dropbox.py,sha256=Dyam1ULTkoxD1X5trkZ5dGp5XhBGCn998moC8IS9-68,9804
+lyrics_transcriber/transcribers/audioshake.py,sha256=QzKGimVa6BovlvYFj35CbGpaGePI_DApAJGEBR_JQLc,8709
+lyrics_transcriber/transcribers/base_transcriber.py,sha256=yPzUWPTCGmzE97H5Rz6g61e-qEGL77ZzUoiBOmswhts,5973
+lyrics_transcriber/transcribers/whisper.py,sha256=P0kas2_oX16MO1-Qy7U5gl5KQN-RuUIJZz7LsEFLUiE,12906
+lyrics_transcriber/types.py,sha256=xGf3hkTRcGZTTAjMVIev2i2DOU6co0QGpW8NxvaBQAA,16759
+lyrics_transcriber-0.32.2.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
+lyrics_transcriber-0.32.2.dist-info/METADATA,sha256=_eW3ZTF3vCxCPtfJRzKgedrQ8VmaL1b244mAlxO71tY,5856
+lyrics_transcriber-0.32.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+lyrics_transcriber-0.32.2.dist-info/entry_points.txt,sha256=ChnmR13YoalGnC3sHW0TppX5FbhEXntYIha24tVQJ1M,104
+lyrics_transcriber-0.32.2.dist-info/RECORD,,

{lyrics_transcriber-0.30.1.dist-info → lyrics_transcriber-0.32.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any

{lyrics_transcriber-0.30.1.dist-info → lyrics_transcriber-0.32.2.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
 lyrics-transcriber=lyrics_transcriber.cli.cli_main:main
+test-cov=tests.conftest:main
 

lyrics_transcriber/correction/base_strategy.py

@@ -1,29 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Protocol
-
-from lyrics_transcriber.lyrics.base_lyrics_provider import LyricsData
-from ..transcribers.base_transcriber import LyricsSegment, TranscriptionResult
-
-
-@dataclass
-class CorrectionResult:
-    """Container for correction results."""
-
-    segments: List[LyricsSegment]
-    text: str
-    confidence: float
-    corrections_made: int
-    source_mapping: Dict[str, str]  # Maps corrected words to their source
-    metadata: Dict[str, Any]
-
-
-class CorrectionStrategy(Protocol):
-    """Interface for different lyrics correction strategies."""
-
-    def correct(
-        self,
-        transcription_results: List[TranscriptionResult],
-        lyrics_results: List[LyricsData],
-    ) -> CorrectionResult:
-        """Apply correction strategy to transcribed lyrics."""
-        ...  # pragma: no cover