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

lyrics_transcriber/lyrics/base_lyrics_provider.py

@@ -0,0 +1,125 @@
+from dataclasses import dataclass
+import logging
+from typing import Optional, Dict, Any
+import json
+import hashlib
+from pathlib import Path
+import os
+from abc import ABC, abstractmethod
+from lyrics_transcriber.types import LyricsData
+
+
+@dataclass
+class LyricsProviderConfig:
+    """Configuration for lyrics providers."""
+
+    genius_api_token: Optional[str] = None
+    spotify_cookie: Optional[str] = None
+    cache_dir: Optional[str] = None
+    audio_filepath: Optional[str] = None
+
+
+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
+        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)
+
+        file_hash = self._get_file_hash(self.audio_filepath)
+        raw_cache_path = self._get_cache_path(file_hash, "raw")
+
+        # Try to load from cache first
+        raw_data = self._load_from_cache(raw_cache_path)
+        if raw_data is not None:
+            self.logger.info(f"Using cached lyrics for {artist} - {title}")
+            return self._save_and_convert_result(file_hash, raw_data)
+
+        # 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)
+            return self._save_and_convert_result(file_hash, raw_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 _save_and_convert_result(self, cache_key: str, raw_data: Dict[str, Any]) -> LyricsData:
+        """Convert raw result to standardized format, save to cache, and return."""
+        converted_cache_path = self._get_cache_path(cache_key, "converted")
+        converted_result = self._convert_result_format(raw_data)
+        # Convert to dictionary before saving to cache
+        self._save_to_cache(converted_cache_path, converted_result.to_dict())
+        return converted_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", "")

lyrics_transcriber/lyrics/genius.py

@@ -0,0 +1,73 @@
+import logging
+from typing import Optional, Dict, Any
+import lyricsgenius
+from lyrics_transcriber.types import LyricsData, LyricsMetadata
+from lyrics_transcriber.lyrics.base_lyrics_provider import BaseLyricsProvider, LyricsProviderConfig
+
+
+class GeniusProvider(BaseLyricsProvider):
+    """Handles fetching lyrics from Genius."""
+
+    def __init__(self, config: LyricsProviderConfig, logger: Optional[logging.Logger] = None):
+        super().__init__(config, logger)
+        self.api_token = config.genius_api_token
+        self.client = None
+        if self.api_token:
+            self.client = lyricsgenius.Genius(self.api_token)
+            self.client.verbose = False
+            self.client.remove_section_headers = True
+
+    def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
+        """Fetch raw song data from Genius API."""
+        if not self.client:
+            self.logger.warning("No Genius API token provided")
+            return None
+
+        self.logger.info(f"Searching Genius for {artist} - {title}")
+        try:
+            song = self.client.search_song(title, artist)
+            if song:
+                self.logger.info("Found lyrics on Genius")
+                return song.to_dict()
+        except Exception as e:
+            self.logger.error(f"Error fetching from Genius: {str(e)}")
+        return None
+
+    def _convert_result_format(self, raw_data: Dict[str, Any]) -> LyricsData:
+        """Convert Genius's raw API response to standardized format."""
+        # Extract release date components if available
+        release_date = None
+        if release_components := raw_data.get("release_date_components"):
+            year = release_components.get("year")
+            month = release_components.get("month")
+            day = release_components.get("day")
+            if all(x is not None for x in (year, month, day)):
+                release_date = f"{year}-{month:02d}-{day:02d}"
+
+        # Create metadata object
+        metadata = LyricsMetadata(
+            source="genius",
+            track_name=raw_data.get("title", ""),
+            artist_names=raw_data.get("artist_names", ""),
+            album_name=raw_data.get("album", {}).get("name"),
+            lyrics_provider="genius",
+            lyrics_provider_id=str(raw_data.get("id")),
+            is_synced=False,  # Genius doesn't provide synced lyrics
+            provider_metadata={
+                "genius_id": raw_data.get("id"),
+                "release_date": release_date,
+                "page_url": raw_data.get("url"),
+                "annotation_count": raw_data.get("annotation_count"),
+                "lyrics_state": raw_data.get("lyrics_state"),
+                "lyrics_owner_id": raw_data.get("lyrics_owner_id"),
+                "pyongs_count": raw_data.get("pyongs_count"),
+                "verified_annotations": len(raw_data.get("verified_annotations_by", [])),
+                "verified_contributors": len(raw_data.get("verified_contributors", [])),
+                "external_urls": {"genius": raw_data.get("url")},
+            },
+        )
+
+        # Create result object
+        return LyricsData(
+            source="genius", lyrics=raw_data.get("lyrics", ""), segments=[], metadata=metadata
+        )  # Genius doesn't provide timestamp data

lyrics_transcriber/lyrics/spotify.py

@@ -0,0 +1,82 @@
+import logging
+from typing import Optional, Dict, Any
+import syrics.api
+
+from lyrics_transcriber.types import LyricsData, LyricsMetadata, LyricsSegment
+from lyrics_transcriber.lyrics.base_lyrics_provider import BaseLyricsProvider, LyricsProviderConfig
+
+
+class SpotifyProvider(BaseLyricsProvider):
+    """Handles fetching lyrics from Spotify."""
+
+    def __init__(self, config: LyricsProviderConfig, logger: Optional[logging.Logger] = None):
+        super().__init__(config, logger)
+        self.cookie = config.spotify_cookie
+        self.client = syrics.api.Spotify(self.cookie) if self.cookie else None
+
+    def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
+        """Fetch raw data from Spotify APIs using syrics library."""
+        if not self.client:
+            self.logger.warning("No Spotify cookie provided")
+            return None
+
+        try:
+            # Search for track
+            search_query = f"{title} - {artist}"
+            search_results = self.client.search(search_query, type="track", limit=1)
+
+            track_data = search_results["tracks"]["items"][0]
+            self.logger.debug(
+                f"Found track: {track_data['artists'][0]['name']} - {track_data['name']} " f"({track_data['external_urls']['spotify']})"
+            )
+
+            # Get lyrics data
+            lyrics_data = self.client.get_lyrics(track_data["id"])
+            if not lyrics_data:
+                return None
+
+            return {"track_data": track_data, "lyrics_data": lyrics_data}
+        except Exception as e:
+            self.logger.error(f"Error fetching from Spotify: {str(e)}")
+            return None
+
+    def _convert_result_format(self, raw_data: Dict[str, Any]) -> LyricsData:
+        """Convert Spotify's raw API response to standardized format."""
+        track_data = raw_data["track_data"]
+        lyrics_data = raw_data["lyrics_data"]["lyrics"]
+
+        # Convert raw lines to LyricsSegment objects
+        segments = []
+        for line in lyrics_data.get("lines", []):
+            if not line.get("words"):
+                continue
+
+            segment = LyricsSegment(
+                text=line["words"],
+                words=[],  # TODO: Could potentially split words if needed
+                start_time=float(line["startTimeMs"]) / 1000 if line["startTimeMs"] != "0" else None,
+                end_time=float(line["endTimeMs"]) / 1000 if line["endTimeMs"] != "0" else None,
+            )
+            segments.append(segment)
+
+        # Create metadata object
+        metadata = LyricsMetadata(
+            source="spotify",
+            track_name=track_data.get("name"),
+            artist_names=", ".join(artist.get("name", "") for artist in track_data.get("artists", [])),
+            album_name=track_data.get("album", {}).get("name"),
+            duration_ms=track_data.get("duration_ms"),
+            explicit=track_data.get("explicit"),
+            language=lyrics_data.get("language"),
+            is_synced=lyrics_data.get("syncType") == "LINE_SYNCED",
+            lyrics_provider=lyrics_data.get("provider"),
+            lyrics_provider_id=lyrics_data.get("providerLyricsId"),
+            provider_metadata={
+                "spotify_id": track_data.get("id"),
+                "preview_url": track_data.get("preview_url"),
+                "external_urls": track_data.get("external_urls"),
+                "sync_type": lyrics_data.get("syncType"),
+            },
+        )
+
+        return LyricsData(source="spotify", lyrics="\n".join(segment.text for segment in segments), segments=segments, metadata=metadata)

lyrics_transcriber/output/ass/__init__.py

@@ -0,0 +1,21 @@
+from lyrics_transcriber.output.ass.lyrics_screen import LyricsScreen
+from lyrics_transcriber.output.ass.lyrics_line import LyricsLine
+from lyrics_transcriber.output.ass.section_screen import SectionScreen
+from lyrics_transcriber.output.ass.style import Style
+from lyrics_transcriber.output.ass.event import Event
+from lyrics_transcriber.output.ass.config import (
+    ScreenConfig,
+    LineTimingInfo,
+    LineState,
+)
+
+__all__ = [
+    'LyricsScreen',
+    'LyricsLine',
+    'SectionScreen',
+    'Style',
+    'Event',
+    'ScreenConfig',
+    'LineTimingInfo',
+    'LineState',
+]