lyrics-transcriber 0.50.0__py3-none-any.whl → 0.52.1__py3-none-any.whl

lyrics_transcriber/cli/cli_main.py

@@ -1,4 +1,8 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
+import warnings
+# Suppress SyntaxWarnings from third-party packages that haven't updated for Python 3.13
+warnings.filterwarnings("ignore", category=SyntaxWarning)
+
 import argparse
 import logging
 import os
@@ -14,6 +18,7 @@ from lyrics_transcriber.core.controller import TranscriberConfig, LyricsConfig,
 def create_arg_parser() -> argparse.ArgumentParser:
     """Create and configure the argument parser."""
     parser = argparse.ArgumentParser(
+        prog="lyrics-transcriber",
         description="Create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps",
         formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=52),
     )

lyrics_transcriber/correction/anchor_sequence.py

@@ -104,7 +104,7 @@ class AnchorSequenceFinder:
             ref_texts.append(f"{source}:{','.join(words_with_ids)}")
 
         # Also include transcription word IDs to ensure complete matching
-        trans_words_with_ids = [f"{w.text}:{w.id}" for s in transcription_result.segments for w in s.words]
+        trans_words_with_ids = [f"{w.text}:{w.id}" for s in transcription_result.result.segments for w in s.words]
 
         input_str = f"{transcribed}|" f"{','.join(trans_words_with_ids)}|" f"{','.join(ref_texts)}"
         return hashlib.md5(input_str.encode()).hexdigest()
@@ -259,7 +259,7 @@ class AnchorSequenceFinder:
 
         # Get all words from transcription
         all_words = []
-        for segment in transcription_result.segments:
+        for segment in transcription_result.result.segments:
             all_words.extend(segment.words)
 
         # Clean and split texts
@@ -381,11 +381,44 @@ class AnchorSequenceFinder:
         self.logger.info(f"Scoring {len(anchors)} anchors")
 
         # Create word map for scoring
-        word_map = {w.id: w for s in transcription_result.segments for w in s.words}
+        word_map = {w.id: w for s in transcription_result.result.segments for w in s.words}
 
         # Add word map to each anchor for scoring
         for anchor in anchors:
-            anchor.transcribed_words = [word_map[word_id] for word_id in anchor.transcribed_word_ids]
+            # For backwards compatibility, only add transcribed_words if all IDs exist in word_map
+            try:
+                anchor.transcribed_words = [word_map[word_id] for word_id in anchor.transcribed_word_ids]
+                # Also set _words for backwards compatibility with text display
+                anchor._words = [word_map[word_id].text for word_id in anchor.transcribed_word_ids]
+            except KeyError:
+                # This can happen in tests using backwards compatible constructors
+                # Create dummy Word objects with the text from _words if available
+                if hasattr(anchor, '_words') and anchor._words is not None:
+                    from lyrics_transcriber.types import Word
+                    from lyrics_transcriber.utils.word_utils import WordUtils
+                    anchor.transcribed_words = [
+                        Word(
+                            id=word_id,
+                            text=text,
+                            start_time=i * 1.0,
+                            end_time=(i + 1) * 1.0,
+                            confidence=1.0
+                        )
+                        for i, (word_id, text) in enumerate(zip(anchor.transcribed_word_ids, anchor._words))
+                    ]
+                else:
+                    # Create generic word objects for scoring
+                    from lyrics_transcriber.types import Word
+                    anchor.transcribed_words = [
+                        Word(
+                            id=word_id,
+                            text=f"word_{i}",
+                            start_time=i * 1.0,
+                            end_time=(i + 1) * 1.0,
+                            confidence=1.0
+                        )
+                        for i, word_id in enumerate(anchor.transcribed_word_ids)
+                    ]
 
         start_time = time.time()
 
@@ -469,7 +502,7 @@ class AnchorSequenceFinder:
         """Find gaps between anchor sequences in the transcribed text."""
         # Get all words from transcription
         all_words = []
-        for segment in transcription_result.segments:
+        for segment in transcription_result.result.segments:
             all_words.extend(segment.words)
 
         # Clean and split reference texts

lyrics_transcriber/correction/corrector.py

@@ -150,13 +150,14 @@ class LyricsCorrector:
         self.reference_lyrics = lyrics_results
 
         # Get primary transcription
-        primary_transcription = sorted(transcription_results, key=lambda x: x.priority)[0].result
+        primary_transcription_result = sorted(transcription_results, key=lambda x: x.priority)[0]
+        primary_transcription = primary_transcription_result.result
         transcribed_text = " ".join(" ".join(w.text for w in segment.words) for segment in primary_transcription.segments)
 
         # Find anchor sequences and gaps
         self.logger.debug("Finding anchor sequences and gaps")
-        anchor_sequences = self.anchor_finder.find_anchors(transcribed_text, lyrics_results, primary_transcription)
-        gap_sequences = self.anchor_finder.find_gaps(transcribed_text, anchor_sequences, lyrics_results, primary_transcription)
+        anchor_sequences = self.anchor_finder.find_anchors(transcribed_text, lyrics_results, primary_transcription_result)
+        gap_sequences = self.anchor_finder.find_gaps(transcribed_text, anchor_sequences, lyrics_results, primary_transcription_result)
 
         # Store anchor sequences for use in correction handlers
         self._anchor_sequences = anchor_sequences

lyrics_transcriber/correction/handlers/extend_anchor.py

@@ -44,11 +44,6 @@ class ExtendAnchorHandler(GapCorrectionHandler):
 
     def can_handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> Tuple[bool, Dict[str, Any]]:
         """Check if this gap can be handled by extending anchor sequences."""
-        # Check if we have anchor sequences
-        if not data or "anchor_sequences" not in data:
-            self.logger.debug("No anchor sequences available")
-            return False, {}
-
         # Must have reference word IDs
         if not gap.reference_word_ids:
             self.logger.debug("No reference word IDs available.")
@@ -59,25 +54,42 @@ class ExtendAnchorHandler(GapCorrectionHandler):
             self.logger.debug("No word IDs in the gap to process.")
             return False, {}
 
-        # At least one word ID must match between gap and any reference source
-        # in the same position
-        has_match = any(
-            i < len(ref_word_ids) and gap.transcribed_word_ids[i] == ref_word_ids[i]
-            for ref_word_ids in gap.reference_word_ids.values()
-            for i in range(min(len(gap.transcribed_word_ids), len(ref_word_ids)))
-        )
+        # Must have word map to resolve IDs to actual words
+        if not self._validate_data(data):
+            return False, {}
+            
+        word_map = data["word_map"]
+
+        # At least one word must match between gap and any reference source by text content
+        has_match = False
+        for i, trans_word_id in enumerate(gap.transcribed_word_ids):
+            if trans_word_id not in word_map:
+                continue
+            trans_word = word_map[trans_word_id]
+            
+            # Check if this word matches any reference word at the same position
+            for ref_word_ids in gap.reference_word_ids.values():
+                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 trans_word.text.lower() == ref_word.text.lower():
+                            has_match = True
+                            break
+            if has_match:
+                break
 
         self.logger.debug(f"Can handle gap: {has_match}")
-        return has_match, {}
+        return has_match, {"word_map": word_map}
 
     def handle(self, gap: GapSequence, data: Optional[Dict[str, Any]] = None) -> List[WordCorrection]:
         corrections = []
 
         # Get word lookup map from data
-        word_map = data.get("word_map", {})
-        if not word_map:
-            self.logger.error("No word_map provided in data")
+        if not self._validate_data(data):
             return []
+            
+        word_map = data["word_map"]
 
         # Process each word in the gap that has a corresponding reference position
         for i, word_id in enumerate(gap.transcribed_word_ids):
@@ -87,48 +99,51 @@ class ExtendAnchorHandler(GapCorrectionHandler):
                 continue
             word = word_map[word_id]
 
-            # Find reference sources that have a matching word at this position
-            matching_sources = [
-                source for source, ref_word_ids in gap.reference_word_ids.items() if i < len(ref_word_ids) and word_id == ref_word_ids[i]
-            ]
+            # Find reference sources that have a matching word (by text) at this position
+            matching_sources = []
+            corrected_word_id = None
+            
+            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():
+                            matching_sources.append(source)
+                            if corrected_word_id is None:
+                                corrected_word_id = ref_word_id
 
             if not matching_sources:
                 self.logger.debug(f"Skipping word '{word.text}' at position {i} - no matching references")
                 continue
 
-            if matching_sources:
-                # Word matches reference(s) at this position - validate it
-                confidence = len(matching_sources) / len(gap.reference_word_ids)
-                sources = ", ".join(matching_sources)
-
-                # Get base reference positions
-                base_reference_positions = WordOperations.calculate_reference_positions(gap, matching_sources)
-
-                # Adjust reference positions based on the word's position in the reference text
-                reference_positions = {}
-                for source in matching_sources:
-                    if source in base_reference_positions:
-                        # Find this word's position in the reference text
-                        ref_word_ids = gap.reference_word_ids[source]
-                        for ref_idx, ref_word_id in enumerate(ref_word_ids):
-                            if ref_word_id == word_id:
-                                reference_positions[source] = base_reference_positions[source] + ref_idx
-                                break
-
-                corrections.append(
-                    WordOperations.create_word_replacement_correction(
-                        original_word=word.text,
-                        corrected_word=word.text,
-                        original_position=gap.transcription_position + i,
-                        source=sources,
-                        confidence=confidence,
-                        reason="Matched reference source(s)",
-                        reference_positions=reference_positions,
-                        handler="ExtendAnchorHandler",
-                        original_word_id=word_id,
-                        corrected_word_id=word_id,
-                    )
+            # Word matches reference(s) at this position - validate it
+            confidence = len(matching_sources) / len(gap.reference_word_ids)
+            sources = ", ".join(matching_sources)
+
+            # Get base reference positions
+            base_reference_positions = WordOperations.calculate_reference_positions(gap, matching_sources)
+
+            # Adjust reference positions based on the word's position in the reference text
+            reference_positions = {}
+            for source in matching_sources:
+                if source in base_reference_positions:
+                    reference_positions[source] = base_reference_positions[source] + i
+
+            corrections.append(
+                WordOperations.create_word_replacement_correction(
+                    original_word=word.text,
+                    corrected_word=word.text,
+                    original_position=gap.transcription_position + i,
+                    source=sources,
+                    confidence=confidence,
+                    reason="Matched reference source(s)",
+                    reference_positions=reference_positions,
+                    handler="ExtendAnchorHandler",
+                    original_word_id=word_id,
+                    corrected_word_id=corrected_word_id,
                 )
-                self.logger.debug(f"Validated word '{word.text}' with confidence {confidence} from sources: {sources}")
+            )
+            self.logger.debug(f"Validated word '{word.text}' with confidence {confidence} from sources: {sources}")
 
         return corrections

lyrics_transcriber/correction/text_utils.py

@@ -12,13 +12,17 @@ def clean_text(text: str) -> str:
         - All text converted to lowercase
         - Multiple spaces/whitespace collapsed to single space
         - Leading/trailing whitespace removed
-        - Punctuation removed (except for internal hyphens/slashes in words)
+        - Hyphens and forward slashes replaced with spaces
+        - Apostrophes and other punctuation removed
     """
     # Convert to lowercase
     text = text.lower()
 
-    # Remove punctuation except hyphens and slashes that are between word characters
-    text = re.sub(r"(?<!\w)[^\w\s]|[^\w\s](?!\w)", "", text)
+    # Replace hyphens and forward slashes with spaces
+    text = re.sub(r"[-/]", " ", text)
+    
+    # Remove apostrophes and other punctuation
+    text = re.sub(r"[^\w\s]", "", text)
 
     # Normalize whitespace (collapse multiple spaces, remove leading/trailing)
     text = " ".join(text.split())

lyrics_transcriber/lyrics/file_provider.py

@@ -20,7 +20,7 @@ class FileProvider(BaseLyricsProvider):
         """Get lyrics for the specified artist and title."""
         self.title = title  # Store title for use in other methods
         self.artist = artist  # Store artist for use in other methods
-        return super().get_lyrics(artist, title)
+        return super().fetch_lyrics(artist, title)
 
     def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
         """Load lyrics from the specified file."""
@@ -41,9 +41,14 @@ class FileProvider(BaseLyricsProvider):
         self.logger.debug(f"File size: {lyrics_file.stat().st_size} bytes")
 
         try:
+            # Get formatter safely
+            formatter = None
+            if self.logger.handlers and len(self.logger.handlers) > 0 and hasattr(self.logger.handlers[0], 'formatter'):
+                formatter = self.logger.handlers[0].formatter
+            
             processor = KaraokeLyricsProcessor(
                 log_level=self.logger.getEffectiveLevel(),
-                log_formatter=self.logger.handlers[0].formatter if self.logger.handlers else None,
+                log_formatter=formatter,
                 input_filename=str(lyrics_file),
                 max_line_length=self.max_line_length,
             )

lyrics_transcriber/output/segment_resizer.py

@@ -114,6 +114,7 @@ class SegmentResizer:
         """Create a new word with cleaned text."""
         cleaned_text = self._clean_text(word.text)
         return Word(
+            id=word.id,  # Preserve the original word ID
             text=cleaned_text,
             start_time=word.start_time,
             end_time=word.end_time,

lyrics_transcriber/transcribers/audioshake.py

@@ -41,7 +41,7 @@ class AudioShakeAPI:
         self.logger.info(f"Uploading {filepath} to AudioShake")
         self._validate_config()  # Validate before making API call
 
-        url = f"{self.config.base_url}/upload"
+        url = f"{self.config.base_url}/upload/"
         with open(filepath, "rb") as file:
             files = {"file": (os.path.basename(filepath), file)}
             response = requests.post(url, headers={"Authorization": self._get_headers()["Authorization"]}, files=files)

lyrics_transcriber/types.py

@@ -269,12 +269,67 @@ class AnchorSequence:
     reference_positions: Dict[str, int]  # Source -> position mapping
     reference_word_ids: Dict[str, List[str]]  # Source -> list of Word IDs from reference
     confidence: float
+    
+    # Backwards compatibility: store original words as text for tests
+    _words: Optional[List[str]] = field(default=None, repr=False)
+
+    def __init__(self, *args, **kwargs):
+        """Backwards-compatible constructor supporting both old and new APIs."""
+        # Check for old API usage (either positional args or 'words' keyword)
+        if (len(args) >= 3 and isinstance(args[0], list)) or 'words' in kwargs:
+            # Old API: either AnchorSequence(words, ...) or AnchorSequence(words=..., ...)
+            if 'words' in kwargs:
+                # Keyword argument version
+                words = kwargs.pop('words')
+                transcription_position = kwargs.pop('transcription_position', 0)
+                reference_positions = kwargs.pop('reference_positions', {})
+                confidence = kwargs.pop('confidence', 0.0)
+            else:
+                # Positional argument version (may have confidence as keyword)
+                words = args[0]
+                transcription_position = args[1] if len(args) > 1 else 0
+                reference_positions = args[2] if len(args) > 2 else {}
+                
+                # Handle confidence - could be positional or keyword
+                if len(args) > 3:
+                    confidence = args[3]
+                else:
+                    confidence = kwargs.pop('confidence', 0.0)
+            
+            # Store words for backwards compatibility
+            self._words = words
+            
+            # Create new API fields
+            self.id = kwargs.get('id', WordUtils.generate_id())
+            self.transcribed_word_ids = [WordUtils.generate_id() for _ in words]
+            self.transcription_position = transcription_position
+            self.reference_positions = reference_positions
+            # Create reference_word_ids with same structure as reference_positions
+            self.reference_word_ids = {source: [WordUtils.generate_id() for _ in words] 
+                                     for source in reference_positions.keys()}
+            self.confidence = confidence
+        else:
+            # New API: use keyword arguments
+            self.id = kwargs.get('id', args[0] if len(args) > 0 else WordUtils.generate_id())
+            self.transcribed_word_ids = kwargs.get('transcribed_word_ids', args[1] if len(args) > 1 else [])
+            self.transcription_position = kwargs.get('transcription_position', args[2] if len(args) > 2 else 0)
+            self.reference_positions = kwargs.get('reference_positions', args[3] if len(args) > 3 else {})
+            self.reference_word_ids = kwargs.get('reference_word_ids', args[4] if len(args) > 4 else {})
+            self.confidence = kwargs.get('confidence', args[5] if len(args) > 5 else 0.0)
+            self._words = kwargs.get('_words', None)
+
+    @property
+    def words(self) -> List[str]:
+        """Get the words as a list of strings (backwards compatibility)."""
+        if self._words is not None:
+            return self._words
+        # If we don't have stored words, we can't resolve IDs without a word map
+        # This is a limitation of the backwards compatibility
+        return [f"word_{i}" for i in range(len(self.transcribed_word_ids))]
 
     @property
     def text(self) -> str:
         """Get the sequence as a space-separated string."""
-        # This property might need to be updated to look up words from parent object
-        # For now, keeping it for backwards compatibility
         return " ".join(self.words)
 
     @property
@@ -284,6 +339,18 @@ class AnchorSequence:
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert the anchor sequence to a JSON-serializable dictionary."""
+        # For backwards compatibility, return old format when _words is present
+        if self._words is not None:
+            return {
+                "words": self._words,
+                "text": self.text,
+                "length": self.length,
+                "transcription_position": self.transcription_position,
+                "reference_positions": self.reference_positions,
+                "confidence": self.confidence,
+            }
+        
+        # New format
         return {
             "id": self.id,
             "transcribed_word_ids": self.transcribed_word_ids,
@@ -296,14 +363,26 @@ class AnchorSequence:
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "AnchorSequence":
         """Create AnchorSequence from dictionary."""
-        return cls(
-            id=data.get("id", WordUtils.generate_id()),  # Generate ID if not present in old data
-            transcribed_word_ids=data["transcribed_word_ids"],
-            transcription_position=data["transcription_position"],
-            reference_positions=data["reference_positions"],
-            reference_word_ids=data["reference_word_ids"],
-            confidence=data["confidence"],
-        )
+        # Handle both old and new dictionary formats
+        if "words" in data:
+            # Old format - use backwards compatible constructor
+            return cls(
+                data["words"],
+                data["transcription_position"],
+                data["reference_positions"],
+                data["confidence"],
+                id=data.get("id", WordUtils.generate_id())
+            )
+        else:
+            # New format
+            return cls(
+                id=data.get("id", WordUtils.generate_id()),
+                transcribed_word_ids=data["transcribed_word_ids"],
+                transcription_position=data["transcription_position"],
+                reference_positions=data["reference_positions"],
+                reference_word_ids=data["reference_word_ids"],
+                confidence=data["confidence"],
+            )
 
 
 @dataclass
@@ -354,11 +433,53 @@ class GapSequence:
     reference_word_ids: Dict[str, List[str]]  # Source -> list of Word IDs from reference
     _corrected_positions: Set[int] = field(default_factory=set, repr=False)
     _position_offset: int = field(default=0, repr=False)  # Track cumulative position changes
+    
+    # Backwards compatibility: store original words as text for tests  
+    _words: Optional[List[str]] = field(default=None, repr=False)
+
+    def __init__(self, *args, **kwargs):
+        """Backwards-compatible constructor supporting both old and new APIs."""
+        if len(args) >= 5 and isinstance(args[0], (list, tuple)):
+            # Old API: GapSequence(words, transcription_position, preceding_anchor, following_anchor, reference_words)
+            words, transcription_position, preceding_anchor, following_anchor, reference_words = args[:5]
+            
+            # Store words for backwards compatibility
+            self._words = list(words) if isinstance(words, tuple) else words
+            
+            # Create new API fields
+            self.id = kwargs.get('id', WordUtils.generate_id())
+            self.transcribed_word_ids = [WordUtils.generate_id() for _ in self._words]
+            self.transcription_position = transcription_position
+            self.preceding_anchor_id = getattr(preceding_anchor, 'id', None) if preceding_anchor else None
+            self.following_anchor_id = getattr(following_anchor, 'id', None) if following_anchor else None
+            # Convert reference_words to reference_word_ids
+            self.reference_word_ids = {source: [WordUtils.generate_id() for _ in ref_words] 
+                                     for source, ref_words in reference_words.items()}
+            self._corrected_positions = set()
+            self._position_offset = 0
+        else:
+            # New API: use keyword arguments
+            self.id = kwargs.get('id', args[0] if len(args) > 0 else WordUtils.generate_id())
+            self.transcribed_word_ids = kwargs.get('transcribed_word_ids', args[1] if len(args) > 1 else [])
+            self.transcription_position = kwargs.get('transcription_position', args[2] if len(args) > 2 else 0)
+            self.preceding_anchor_id = kwargs.get('preceding_anchor_id', args[3] if len(args) > 3 else None)
+            self.following_anchor_id = kwargs.get('following_anchor_id', args[4] if len(args) > 4 else None)
+            self.reference_word_ids = kwargs.get('reference_word_ids', args[5] if len(args) > 5 else {})
+            self._corrected_positions = kwargs.get('_corrected_positions', set())
+            self._position_offset = kwargs.get('_position_offset', 0)
+            self._words = kwargs.get('_words', None)
+
+    @property
+    def words(self) -> List[str]:
+        """Get the words as a list of strings (backwards compatibility)."""
+        if self._words is not None:
+            return self._words
+        # If we don't have stored words, we can't resolve IDs without a word map
+        return [f"word_{i}" for i in range(len(self.transcribed_word_ids))]
 
     @property
     def text(self) -> str:
         """Get the sequence as a space-separated string."""
-        # This property might need to be updated to look up words from parent object
         return " ".join(self.words)
 
     @property
@@ -368,7 +489,7 @@ class GapSequence:
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert the gap sequence to a JSON-serializable dictionary."""
-        return {
+        result = {
             "id": self.id,
             "transcribed_word_ids": self.transcribed_word_ids,
             "transcription_position": self.transcription_position,
@@ -376,19 +497,42 @@ class GapSequence:
             "following_anchor_id": self.following_anchor_id,
             "reference_word_ids": self.reference_word_ids,
         }
+        
+        # For backwards compatibility, include words and text in dict
+        if self._words is not None:
+            result.update({
+                "words": self._words,
+                "text": self.text,
+                "length": self.length,
+            })
+        
+        return result
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "GapSequence":
         """Create GapSequence from dictionary."""
-        gap = cls(
-            id=data.get("id", WordUtils.generate_id()),  # Generate ID if not present in old data
-            transcribed_word_ids=data["transcribed_word_ids"],
-            transcription_position=data["transcription_position"],
-            preceding_anchor_id=data["preceding_anchor_id"],
-            following_anchor_id=data["following_anchor_id"],
-            reference_word_ids=data["reference_word_ids"],
-        )
-        return gap
+        # Handle both old and new dictionary formats
+        if "words" in data:
+            # Old format - use backwards compatible constructor
+            return cls(
+                data["words"],
+                data["transcription_position"],
+                None,  # preceding_anchor
+                None,  # following_anchor
+                data.get("reference_words", {}),
+                id=data.get("id", WordUtils.generate_id())
+            )
+        else:
+            # New format
+            gap = cls(
+                id=data.get("id", WordUtils.generate_id()),
+                transcribed_word_ids=data["transcribed_word_ids"],
+                transcription_position=data["transcription_position"],
+                preceding_anchor_id=data["preceding_anchor_id"],
+                following_anchor_id=data["following_anchor_id"],
+                reference_word_ids=data["reference_word_ids"],
+            )
+            return gap
 
 
 @dataclass

{lyrics_transcriber-0.50.0.dist-info → lyrics_transcriber-0.52.1.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 karaokenerds
+Copyright (c) 2024 Nomad Karaoke LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{lyrics_transcriber-0.50.0.dist-info → lyrics_transcriber-0.52.1.dist-info}/METADATA

@@ -1,24 +1,24 @@
 Metadata-Version: 2.3
 Name: lyrics-transcriber
-Version: 0.50.0
+Version: 0.52.1
 Summary: Automatically create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps, using Whisper and lyrics from Genius and Spotify
 License: MIT
 Author: Andrew Beveridge
 Author-email: andrew@beveridge.uk
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.10,<3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: attrs (>=23.0.0)
 Requires-Dist: cattrs (>=23.0.0)
 Requires-Dist: dropbox (>=12)
 Requires-Dist: fastapi (>=0.115)
 Requires-Dist: ffmpeg-python (>=0.2.0)
 Requires-Dist: fonttools (>=4.55)
-Requires-Dist: karaoke-lyrics-processor (>=0.4)
+Requires-Dist: karaoke-lyrics-processor (>=0.6)
 Requires-Dist: lyricsgenius (>=0.1.0)
 Requires-Dist: metaphone (>=0.6)
 Requires-Dist: nltk (>=3.9)
@@ -30,23 +30,28 @@ Requires-Dist: python-dotenv (>=1)
 Requires-Dist: python-levenshtein (>=0.26)
 Requires-Dist: python-slugify (>=8)
 Requires-Dist: shortuuid (>=1.0.13,<2.0.0)
-Requires-Dist: spacy (>=3.8)
+Requires-Dist: spacy (>=3.8.7)
 Requires-Dist: spacy-syllables (>=3)
+Requires-Dist: srsly (>=2.5.1)
 Requires-Dist: syllables (>=1)
 Requires-Dist: syrics (>=0)
 Requires-Dist: toml (>=0.10.0)
-Requires-Dist: torch (<2.5)
+Requires-Dist: torch (>=2.7,<3.0)
 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
+Project-URL: Documentation, https://github.com/nomadkaraoke/python-lyrics-transcriber/blob/main/README.md
+Project-URL: Homepage, https://github.com/nomadkaraoke/python-lyrics-transcriber
+Project-URL: Repository, https://github.com/nomadkaraoke/python-lyrics-transcriber
 Description-Content-Type: text/markdown
 
 # Lyrics Transcriber 🎶
 
-[![PyPI version](https://badge.fury.io/py/lyrics-transcriber.svg)](https://badge.fury.io/py/lyrics-transcriber)
+![PyPI - Version](https://img.shields.io/pypi/v/lyrics-transcriber)
+![Python Version](https://img.shields.io/badge/python-3.10+-blue)
+[![Tests](https://github.com/nomadkaraoke/python-lyrics-transcriber/actions/workflows/test-and-publish.yml/badge.svg)](https://github.com/nomadkaraoke/python-lyrics-transcriber/actions/workflows/test-and-publish.yml)
+![Test Coverage](https://codecov.io/gh/nomadkaraoke/lyrics-transcriber/branch/main/graph/badge.svg)
+
 
 Automatically create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps, using OpenAI Whisper and lyrics from Genius and Spotify, for convenience in use cases such as karaoke video production.
 

{lyrics_transcriber-0.50.0.dist-info → lyrics_transcriber-0.52.1.dist-info}/RECORD

@@ -1,14 +1,14 @@
 lyrics_transcriber/__init__.py,sha256=g9ZbJg9U1qo7XzrC25J3bTKcNzzwUJWDVdi_7-hjcM4,412
 lyrics_transcriber/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lyrics_transcriber/cli/cli_main.py,sha256=fp8IOfuuUdUYSTeXFkaiZr25IwwohBbgOY14VVGZenc,10448
+lyrics_transcriber/cli/cli_main.py,sha256=kMWoV_89KRD2XAU39Brs2rdkbQmG6OxrEn7SAh2zCTM,10648
 lyrics_transcriber/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyrics_transcriber/core/config.py,sha256=euwOOtuNbXy4-a1xs8QKdjcf5jXZQle0zf6X1Wthurw,1229
 lyrics_transcriber/core/controller.py,sha256=66qwIv-2jEW94wU5RVFRIcfrTyszC-aC_Fcx5dCjG7k,20255
-lyrics_transcriber/correction/anchor_sequence.py,sha256=QB9_74YsMTMRyEqNNqaSx-6MEO7mmkKstywfvkujT7g,30089
-lyrics_transcriber/correction/corrector.py,sha256=cMraMRE27RtWN7BocM77NDNCLY1FV4ocKM8dP7bVcuQ,20848
+lyrics_transcriber/correction/anchor_sequence.py,sha256=bodjprc3Sc2ykFBXUjwoX77OHcElc2q_sfqMOG36XwU,31869
+lyrics_transcriber/correction/corrector.py,sha256=wwSLHat4SGKEJffFQVcmSfMN_I8Drv-jpeTkO8ndLu0,20930
 lyrics_transcriber/correction/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyrics_transcriber/correction/handlers/base.py,sha256=ZXYMFgbCmlD62dpqdFwFPlcePdHKEFrABffnG_Mu5mI,1687
-lyrics_transcriber/correction/handlers/extend_anchor.py,sha256=wGGEtVmcEdYOTNuQQFz7Afhpfnn4Su0soiPmnY0dIRo,5944
+lyrics_transcriber/correction/handlers/extend_anchor.py,sha256=IADgdPmEMokUQhh6mP-wQWLYf6GfWTvJbBjOk08A-aw,6384
 lyrics_transcriber/correction/handlers/levenshtein.py,sha256=hMERQHVgiUDSHtamYrAjqZ3qMMok4VmQ_MYM2-nrX6w,7864
 lyrics_transcriber/correction/handlers/llm.py,sha256=ufqHtohdU5dUXE3DikzbloAWGVgMu1wnw6P4WHRmpdk,14580
 lyrics_transcriber/correction/handlers/llm_providers.py,sha256=MV-KCRseccg-DEimMS0D2bXJ2xhy59r2n8UZjICUoEY,2067
@@ -20,7 +20,7 @@ lyrics_transcriber/correction/handlers/syllables_match.py,sha256=c9_hrJb_xkkqd2S
 lyrics_transcriber/correction/handlers/word_count_match.py,sha256=OltTEs6eYnslxdvak97M5gXDiqXJxMHKk__Q9F_akXc,3595
 lyrics_transcriber/correction/handlers/word_operations.py,sha256=410xhyO9tiqezV5yd5JKwKbxSGwXK9LWHJ7-zNIuOWA,7423
 lyrics_transcriber/correction/phrase_analyzer.py,sha256=dtO_2LjxnPdHJM7De40mYIdHCkozwhizVVQp5XGO7x0,16962
-lyrics_transcriber/correction/text_utils.py,sha256=z4eiTBCmkNeTUvxG_RpR1Zwg0cbMPKFyxVaKAvLAk88,761
+lyrics_transcriber/correction/text_utils.py,sha256=7QHK6-PY7Rx1G1E31sWiLBw00mHorRDo-M44KMHFaZs,833
 lyrics_transcriber/frontend/.gitignore,sha256=lgGIPiVpFVUNSZl9oNQLelLOWUzpF7sikLW8xmsrrqI,248
 lyrics_transcriber/frontend/.yarn/install-state.gz,sha256=kcgQ-S9HvdNHexkXQVt18LWUpqtP2mdyRfjJV1htFAc,345895
 lyrics_transcriber/frontend/.yarn/releases/yarn-4.7.0.cjs,sha256=KTYy2KCV2OpHhussV5jIPDdUSr7RftMRhqPsRUmgfAY,2765465
@@ -87,7 +87,7 @@ lyrics_transcriber/frontend/vite.config.js,sha256=P4GuPgRZzwEWPQZpyujUe7eA3mjPoF
 lyrics_transcriber/frontend/vite.config.ts,sha256=8FdW0dN8zDFqfhQSxX5h7sIu72X2piLYlp_TZYRQvBQ,216
 lyrics_transcriber/frontend/yarn.lock,sha256=wtImLsCO1P1Lpkhc1jAN6IiHQ0As4xn39n0cwKoh4LM,131996
 lyrics_transcriber/lyrics/base_lyrics_provider.py,sha256=mqlqssKG2AofvqEU48nCwLnz0FhO9Ee6MNixF6GBnYY,9133
-lyrics_transcriber/lyrics/file_provider.py,sha256=ksjVCtzzyK1lhKrYBed0P61wR3TV998Em2Dr7raqWwk,4086
+lyrics_transcriber/lyrics/file_provider.py,sha256=WNd6mHMV2FhrnHiWBvxUxPkdVi47mbLE4hXaTYqStTM,4290
 lyrics_transcriber/lyrics/genius.py,sha256=SIMFEmD_QbXUB8hpDhRU7AAyVrJbRvKyTWsShA9jecE,5693
 lyrics_transcriber/lyrics/spotify.py,sha256=K7aL_OHdQjhI8ydnHUq8-PUvkyDu2s-et7njiLIBVgY,5457
 lyrics_transcriber/lyrics/user_input_provider.py,sha256=oNzwjk2bOQYyUXvVqPcbrF8vJU7LLtwTvJTXxtPaQto,1798
@@ -138,20 +138,20 @@ lyrics_transcriber/output/generator.py,sha256=dpEIqdX0Dc0_kpfOoZMxGryVIopSRSgnV7
 lyrics_transcriber/output/lrc_to_cdg.py,sha256=2pi5tvreD_ADAR4RF5yVwj7OJ4Pf5Zo_EJ7rt4iH3k0,2063
 lyrics_transcriber/output/lyrics_file.py,sha256=_KQyQjCOMIwQdQ0115uEAUIjQWTRmShkSfQuINPKxaw,3741
 lyrics_transcriber/output/plain_text.py,sha256=XARaWcy6MeQeQCUoz0PV_bHoBw5dba-u79bjS7XucnE,3867
-lyrics_transcriber/output/segment_resizer.py,sha256=R2Z15F7aa7DQwgAf0EMNIQ-aYQhjs0JbhqoK_bW5hCA,17453
+lyrics_transcriber/output/segment_resizer.py,sha256=rrgcQC28eExSAmGnm6ytkF-E-nH4Fe3gjvpaCD0MCmA,17510
 lyrics_transcriber/output/subtitles.py,sha256=yQCR7YO3aitKnGRjfAtSwsdi6byfpEZgnCumJO16M2E,19085
 lyrics_transcriber/output/video.py,sha256=L_KB33YM4X-EQBRcLIPO4ZqlNEcVwqTWKjaJZVtkN-4,13751
 lyrics_transcriber/review/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyrics_transcriber/review/server.py,sha256=D5wMRdwdjW7Y1KnL4dON1rIrZpJg7jhqU_lK1q4ssqg,27445
 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=pUR--5DgpYyJ-RFqdoLDf_2cHXI5CO239r5deDZRXVc,8938
+lyrics_transcriber/transcribers/audioshake.py,sha256=hLlnRfkYldP8Y0dMCCwjYlLwqUZPAP7Xzk59G3u5bq0,8939
 lyrics_transcriber/transcribers/base_transcriber.py,sha256=T3m4ZCwZ9Bpv6Jvb2hNcnllk-lmeNmADDJlSySBtP1Q,6480
 lyrics_transcriber/transcribers/whisper.py,sha256=YcCB1ic9H6zL1GS0jD0emu8-qlcH0QVEjjjYB4aLlIQ,13260
-lyrics_transcriber/types.py,sha256=d73cDstrEI_tVgngDYYYFwjZNs6OVBuAB_QDkga7dWA,19841
+lyrics_transcriber/types.py,sha256=_YfZuU2KvZyDaYQgx5CGkbOxfR5ffdTOAx6Fk58DC14,27283
 lyrics_transcriber/utils/word_utils.py,sha256=-cMGpj9UV4F6IsoDKAV2i1aiqSO8eI91HMAm_igtVMk,958
-lyrics_transcriber-0.50.0.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
-lyrics_transcriber-0.50.0.dist-info/METADATA,sha256=paOOVpWfkKFNFSl0GWY3fmG6ps1ni-iA9dtrp_-yOaA,6185
-lyrics_transcriber-0.50.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-lyrics_transcriber-0.50.0.dist-info/entry_points.txt,sha256=kcp-bSFkCACAEA0t166Kek0HpaJUXRo5SlF5tVrqNBU,216
-lyrics_transcriber-0.50.0.dist-info/RECORD,,
+lyrics_transcriber-0.52.1.dist-info/LICENSE,sha256=81R_4XwMZDODHD7JcZeUR8IiCU8AD7Ajl6bmwR9tYDk,1074
+lyrics_transcriber-0.52.1.dist-info/METADATA,sha256=MPYPP8PSObB0sUU72tpCHR3_7sWoytFJg2N2xpOIJvM,6566
+lyrics_transcriber-0.52.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+lyrics_transcriber-0.52.1.dist-info/entry_points.txt,sha256=kcp-bSFkCACAEA0t166Kek0HpaJUXRo5SlF5tVrqNBU,216
+lyrics_transcriber-0.52.1.dist-info/RECORD,,