Files
karaoke-gen/karaoke_gen/lyrics_transcriber/lyrics/base_lyrics_provider.py
T
Andrew Beveridge ☄️andClaude Opus 4.5 404c6e6133 fix: make lyrics_transcriber a subpackage of karaoke_gen (#299)
## Summary
Fixes the deployment failure from PR #297 by making lyrics_transcriber a
proper subpackage of karaoke_gen instead of a separate vendored library.

### Changes
- Move `libs/lyrics_transcriber/` to `karaoke_gen/lyrics_transcriber/`
- Update all imports from `from lyrics_transcriber.X` to `from
karaoke_gen.lyrics_transcriber.X`
- Simplify Dockerfile (no separate `libs/` COPY needed)
- Update pyproject.toml to remove separate package entry
- Update test mocks and logger names

### Why this is better
- Cleaner project structure - one package containing everything
- Simpler Dockerfile - just COPY karaoke_gen/
- No confusion about vendored vs internal code

## Test plan
- [x] `poetry install` succeeds
- [x] All imports work correctly
- [x] All 2614 tests pass
- [ ] Backend deployment succeeds

@coderabbitai ignore

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 16:53:34 +00:00

212 lines
9.0 KiB
Python

from dataclasses import dataclass
import logging
from typing import Optional, Dict, Any, List
import json
import hashlib
from pathlib import Path
import os
from abc import ABC, abstractmethod
from karaoke_gen.lyrics_transcriber.types import LyricsData, LyricsSegment, Word
from karaoke_lyrics_processor import KaraokeLyricsProcessor
from karaoke_gen.lyrics_transcriber.utils.word_utils import WordUtils
@dataclass
class LyricsProviderConfig:
"""Configuration for lyrics providers."""
genius_api_token: Optional[str] = None
rapidapi_key: Optional[str] = None
spotify_cookie: Optional[str] = None
lyrics_file: Optional[str] = None
cache_dir: Optional[str] = None
audio_filepath: Optional[str] = None
max_line_length: int = 36 # Config parameter for KaraokeLyricsProcessor
class BaseLyricsProvider(ABC):
"""Base class for lyrics providers."""
def __init__(self, config: LyricsProviderConfig, logger: Optional[logging.Logger] = None):
self.logger = logger or logging.getLogger(__name__)
self.cache_dir = Path(config.cache_dir) if config.cache_dir else None
self.audio_filepath = config.audio_filepath
self.max_line_length = config.max_line_length
if self.cache_dir:
self.cache_dir.mkdir(parents=True, exist_ok=True)
self.logger.debug(f"Initialized {self.__class__.__name__} with cache dir: {self.cache_dir}")
def fetch_lyrics(self, artist: str, title: str) -> Optional[LyricsData]:
"""Fetch lyrics for a given artist and title, using cache if available."""
if not self.cache_dir:
return self._fetch_and_convert_result(artist, title)
# Use artist and title for cache key instead of audio file hash
cache_key = self._get_artist_title_hash(artist, title)
# Check converted cache first
converted_cache_path = self._get_cache_path(cache_key, "converted")
converted_data = self._load_from_cache(converted_cache_path)
if converted_data:
self.logger.info(f"Using cached converted lyrics for {artist} - {title} from file: {converted_cache_path}")
return LyricsData.from_dict(converted_data)
# Check raw cache next
raw_cache_path = self._get_cache_path(cache_key, "raw")
raw_data = self._load_from_cache(raw_cache_path)
if raw_data:
self.logger.info(f"Using cached raw lyrics for {artist} - {title} from file: {raw_cache_path}")
converted_result = self._convert_result_format(raw_data)
self._save_to_cache(converted_cache_path, converted_result.to_dict())
return converted_result
# If not in cache, fetch from source
raw_result = self._fetch_data_from_source(artist, title)
if raw_result:
# Save raw API response
self._save_to_cache(raw_cache_path, raw_result)
converted_result = self._convert_result_format(raw_result)
self._save_to_cache(converted_cache_path, converted_result.to_dict())
return converted_result
return None
def _get_file_hash(self, filepath: str) -> str:
"""Calculate MD5 hash of a file."""
self.logger.debug(f"Calculating hash for file: {filepath}")
md5_hash = hashlib.md5()
with open(filepath, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
md5_hash.update(chunk)
hash_result = md5_hash.hexdigest()
self.logger.debug(f"File hash: {hash_result}")
return hash_result
def _get_artist_title_hash(self, artist: str, title: str) -> str:
"""Calculate MD5 hash of the artist and title."""
combined = f"{artist.lower()}_{title.lower()}"
return hashlib.md5(combined.encode()).hexdigest()
def _get_cache_path(self, cache_key: str, suffix: str) -> str:
"""Get the cache file path for a given cache key and suffix."""
return os.path.join(self.cache_dir, f"{self.get_name().lower()}_{cache_key}_{suffix}.json")
def _save_to_cache(self, cache_path: str, data: Dict[str, Any]) -> None:
"""Save data to cache."""
self.logger.debug(f"Saving lyrics to cache: {cache_path}")
with open(cache_path, "w", encoding="utf-8") as f:
json.dump(data, f, indent=2, ensure_ascii=False)
self.logger.debug("Cache save completed")
def _load_from_cache(self, cache_path: str) -> Optional[Dict[str, Any]]:
"""Load data from cache if it exists."""
self.logger.debug(f"Attempting to load from cache: {cache_path}")
try:
with open(cache_path, "r", encoding="utf-8") as f:
data = json.load(f)
self.logger.debug("Lyrics loaded from cache")
return data
except FileNotFoundError:
self.logger.debug("Cache file not found")
return None
except json.JSONDecodeError:
self.logger.warning(f"Cache file {cache_path} is corrupted")
return None
def _create_segments_with_words(self, text: str, is_synced: bool = False) -> List[LyricsSegment]:
"""Create LyricsSegment objects with properly formatted words from text.
Args:
text: Raw lyrics text
is_synced: Whether timing information is available
Returns:
List of LyricsSegment objects with unique IDs and Word objects
"""
segments = []
lines = text.strip().split("\n")
for line in lines:
if not line.strip():
continue
# Split line into words
word_texts = line.strip().split()
if not word_texts:
continue
words = []
for word_text in word_texts:
word = Word(
id=WordUtils.generate_id(),
text=word_text,
start_time=0.0 if is_synced else None,
end_time=0.0 if is_synced else None,
confidence=1.0, # Reference lyrics are considered ground truth
created_during_correction=False,
)
words.append(word)
segment = LyricsSegment(
id=WordUtils.generate_id(),
text=line.strip(),
words=words,
start_time=words[0].start_time if is_synced else None,
end_time=words[-1].end_time if is_synced else None,
)
segments.append(segment)
return segments
def _process_lyrics(self, lyrics_data: LyricsData) -> LyricsData:
"""Process lyrics using KaraokeLyricsProcessor and create proper segments."""
# Concatenate all segment texts to get the full lyrics
full_lyrics = lyrics_data.get_full_text()
processor = KaraokeLyricsProcessor(
log_level=self.logger.getEffectiveLevel(),
log_formatter=self.logger.handlers[0].formatter if self.logger.handlers else None,
input_lyrics_text=full_lyrics,
max_line_length=self.max_line_length,
)
processed_text = processor.process()
# Create segments with words from processed text
segments = self._create_segments_with_words(processed_text, is_synced=lyrics_data.metadata.is_synced)
# Create new LyricsData with processed text and segments
return LyricsData(source=lyrics_data.source, segments=segments, metadata=lyrics_data.metadata)
def _save_and_convert_result(self, cache_key: str, raw_data: Dict[str, Any]) -> LyricsData:
"""Convert raw result to standardized format, process lyrics, save to cache, and return."""
converted_cache_path = self._get_cache_path(cache_key, "converted")
converted_result = self._convert_result_format(raw_data)
# Process the lyrics
processed_result = self._process_lyrics(converted_result)
# Convert to dictionary before saving to cache
self._save_to_cache(converted_cache_path, processed_result.to_dict())
return processed_result
def _fetch_and_convert_result(self, artist: str, title: str) -> Optional[LyricsData]:
"""Fetch and convert result when caching is disabled."""
raw_result = self._fetch_data_from_source(artist, title)
if raw_result:
return self._convert_result_format(raw_result)
return None
@abstractmethod
def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
"""Fetch raw data from the source (implemented by subclasses)."""
raise NotImplementedError("Subclasses must implement _fetch_data_from_source") # pragma: no cover
@abstractmethod
def _convert_result_format(self, raw_data: Dict[str, Any]) -> LyricsData:
"""Convert raw API response to standardized format (implemented by subclasses)."""
raise NotImplementedError("Subclasses must implement _convert_result_format") # pragma: no cover
def get_name(self) -> str:
"""Return the name of this lyrics provider."""
return self.__class__.__name__.replace("Provider", "")