PyPI - lyrics-transcriber - Versions diffs - 0.59.0__py3-none-any.whl → 0.61.0__py3-none-any.whl - Mend

lyrics-transcriber 0.59.0py3-none-any.whl → 0.61.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

lyrics_transcriber/frontend/web_assets/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Lyrics Transcriber Analyzer</title>
-    <script type="module" crossorigin src="/assets/index-HT4AHF8U.js"></script>
+    <script type="module" crossorigin src="/assets/index-Cy8N8ZKR.js"></script>
   </head>
   <body>
     <div id="root"></div>

lyrics_transcriber/lyrics/genius.py CHANGED Viewed

@@ -15,7 +15,8 @@ class GeniusProvider(BaseLyricsProvider):
         self.api_token = config.genius_api_token
         self.rapidapi_key = config.rapidapi_key
         self.client = None
-        if self.api_token:
+        # Only initialize lyricsgenius client if rapidapi_key is not set
+        if self.api_token and not self.rapidapi_key:
             self.client = lyricsgenius.Genius(
                 self.api_token,
                 verbose=(logger.getEffectiveLevel() == logging.DEBUG if logger else False),

lyrics_transcriber/lyrics/musixmatch.py ADDED Viewed

@@ -0,0 +1,156 @@
+import logging
+from typing import Optional, Dict, Any
+import requests
+from lyrics_transcriber.types import LyricsData, LyricsMetadata
+from lyrics_transcriber.lyrics.base_lyrics_provider import BaseLyricsProvider, LyricsProviderConfig
+class MusixmatchProvider(BaseLyricsProvider):
+    """Handles fetching lyrics from Musixmatch via RapidAPI."""
+    def __init__(self, config: LyricsProviderConfig, logger: Optional[logging.Logger] = None):
+        super().__init__(config, logger)
+        self.rapidapi_key = config.rapidapi_key
+    def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
+        """Fetch raw song data from Musixmatch via RapidAPI."""
+        if not self.rapidapi_key:
+            self.logger.warning("No RapidAPI key provided for Musixmatch")
+            return None
+        self.logger.info(f"Fetching lyrics from Musixmatch for {artist} - {title}")
+        try:
+            # Construct the API URL with artist and title
+            url = f"https://musixmatch-song-lyrics-api.p.rapidapi.com/lyrics/{artist}/{title}/"
+            headers = {
+                "x-rapidapi-key": self.rapidapi_key,
+                "x-rapidapi-host": "musixmatch-song-lyrics-api.p.rapidapi.com"
+            }
+            self.logger.debug(f"Making Musixmatch API request to: {url}")
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            # Check if we got a valid response
+            if not data.get("message", {}).get("body", {}).get("macro_calls"):
+                self.logger.warning("Invalid response structure from Musixmatch API")
+                return None
+            # Check if lyrics are available
+            lyrics_data = data.get("message", {}).get("body", {}).get("macro_calls", {}).get("track.lyrics.get", {})
+            if not lyrics_data.get("message", {}).get("body", {}).get("lyrics"):
+                self.logger.warning("No lyrics found in Musixmatch response")
+                return None
+            self.logger.info("Successfully fetched lyrics from Musixmatch")
+            return data
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Musixmatch API request failed: {str(e)}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error fetching from Musixmatch: {str(e)}")
+            return None
+    def _convert_result_format(self, raw_data: Dict[str, Any]) -> LyricsData:
+        """Convert Musixmatch's raw API response to standardized format."""
+        try:
+            # Extract macro calls from the nested response
+            macro_calls = raw_data.get("message", {}).get("body", {}).get("macro_calls", {})
+            # Extract track information
+            track_data = macro_calls.get("matcher.track.get", {}).get("message", {}).get("body", {}).get("track", {})
+            # Extract lyrics information
+            lyrics_data = macro_calls.get("track.lyrics.get", {}).get("message", {}).get("body", {}).get("lyrics", {})
+            # Get the actual lyrics text
+            lyrics_text = lyrics_data.get("lyrics_body", "")
+            # Clean the lyrics
+            lyrics_text = self._clean_lyrics(lyrics_text)
+            # Create metadata object
+            metadata = LyricsMetadata(
+                source="musixmatch",
+                track_name=track_data.get("track_name", ""),
+                artist_names=track_data.get("artist_name", ""),
+                album_name=track_data.get("album_name", ""),
+                duration_ms=track_data.get("track_length", 0) * 1000 if track_data.get("track_length") else None,
+                explicit=bool(track_data.get("explicit", 0)),
+                language=lyrics_data.get("lyrics_language", ""),
+                is_synced=False,  # Musixmatch API doesn't provide sync data in this format
+                lyrics_provider="musixmatch",
+                lyrics_provider_id=str(lyrics_data.get("lyrics_id", "")),
+                provider_metadata={
+                    "musixmatch_track_id": track_data.get("track_id"),
+                    "musixmatch_lyrics_id": lyrics_data.get("lyrics_id"),
+                    "album_id": track_data.get("album_id"),
+                    "artist_id": track_data.get("artist_id"),
+                    "track_share_url": track_data.get("track_share_url"),
+                    "track_edit_url": track_data.get("track_edit_url"),
+                    "lyrics_language": lyrics_data.get("lyrics_language"),
+                    "lyrics_language_description": lyrics_data.get("lyrics_language_description"),
+                    "lyrics_copyright": lyrics_data.get("lyrics_copyright"),
+                    "track_rating": track_data.get("track_rating"),
+                    "num_favourite": track_data.get("num_favourite"),
+                    "first_release_date": track_data.get("first_release_date"),
+                    "spotify_id": track_data.get("track_spotify_id"),
+                    "isrc": track_data.get("track_isrc"),
+                    "api_source": "rapidapi_musixmatch",
+                },
+            )
+            # Create segments with words from lyrics
+            segments = self._create_segments_with_words(lyrics_text, is_synced=False)
+            # Create result object with segments
+            return LyricsData(source="musixmatch", segments=segments, metadata=metadata)
+        except Exception as e:
+            self.logger.error(f"Error converting Musixmatch response format: {str(e)}")
+            # Return empty lyrics data if conversion fails
+            return LyricsData(
+                source="musixmatch",
+                segments=[],
+                metadata=LyricsMetadata(
+                    source="musixmatch",
+                    track_name="",
+                    artist_names="",
+                    lyrics_provider="musixmatch",
+                    is_synced=False,
+                    provider_metadata={"api_source": "rapidapi_musixmatch", "conversion_error": str(e)},
+                )
+            )
+    def _clean_lyrics(self, lyrics: str) -> str:
+        """Clean and process lyrics from Musixmatch to remove unwanted content."""
+        if not isinstance(lyrics, str):
+            self.logger.warning(f"Expected string for lyrics, got {type(lyrics)}: {repr(lyrics)}")
+            if lyrics is None:
+                return ""
+            try:
+                lyrics = str(lyrics)
+            except Exception as e:
+                self.logger.error(f"Failed to convert lyrics to string: {e}")
+                return ""
+        # Replace escaped newlines with actual newlines, handling whitespace
+        import re
+        lyrics = re.sub(r'\s*\\n\s*', '\n', lyrics)
+        # Remove any HTML tags that might be present
+        lyrics = re.sub(r'<[^>]+>', '', lyrics)
+        # Clean up multiple consecutive newlines
+        lyrics = re.sub(r'\n\s*\n\s*\n+', '\n\n', lyrics)
+        # Clean up leading/trailing whitespace
+        lyrics = lyrics.strip()
+        self.logger.debug("Completed Musixmatch lyrics cleaning process")
+        return lyrics

lyrics_transcriber/lyrics/spotify.py CHANGED Viewed

@@ -2,6 +2,7 @@ import logging
 from typing import Optional, Dict, Any
 import syrics.api
 import time
+import requests
 from lyrics_transcriber.types import LyricsData, LyricsMetadata, LyricsSegment, Word
 from lyrics_transcriber.lyrics.base_lyrics_provider import BaseLyricsProvider, LyricsProviderConfig
@@ -14,9 +15,11 @@ class SpotifyProvider(BaseLyricsProvider):
     def __init__(self, config: LyricsProviderConfig, logger: Optional[logging.Logger] = None):
         super().__init__(config, logger)
         self.cookie = config.spotify_cookie
+        self.rapidapi_key = config.rapidapi_key
         self.client = None
-        if self.cookie:
+        # Only initialize syrics client if rapidapi_key is not set
+        if self.cookie and not self.rapidapi_key:
             max_retries = 5
             retry_delay = 5  # seconds
@@ -32,9 +35,17 @@ class SpotifyProvider(BaseLyricsProvider):
                     time.sleep(retry_delay)
     def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
-        """Fetch raw data from Spotify APIs using syrics library."""
+        """Fetch raw data from Spotify APIs using RapidAPI or syrics library."""
+        # Try RapidAPI first if available
+        if self.rapidapi_key:
+            self.logger.info(f"Trying RapidAPI for {artist} - {title}")
+            result = self._fetch_from_rapidapi(artist, title)
+            if result:
+                return result
+        # Fall back to syrics library
         if not self.client:
-            self.logger.warning("No Spotify cookie provided")
+            self.logger.warning("No Spotify cookie provided and RapidAPI failed")
             return None
         try:
@@ -57,8 +68,82 @@ class SpotifyProvider(BaseLyricsProvider):
             self.logger.error(f"Error fetching from Spotify: {str(e)}")
             return None
+    def _fetch_from_rapidapi(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
+        """Fetch song data using RapidAPI."""
+        try:
+            # Step 1: Search for the track
+            search_url = "https://spotify-scraper.p.rapidapi.com/v1/track/search"
+            search_params = {
+                "name": f"{title} {artist}"
+            }
+            headers = {
+                "x-rapidapi-key": self.rapidapi_key,
+                "x-rapidapi-host": "spotify-scraper.p.rapidapi.com"
+            }
+            self.logger.debug(f"Making RapidAPI search request for '{artist} {title}'")
+            search_response = requests.get(search_url, headers=headers, params=search_params, timeout=10)
+            search_response.raise_for_status()
+            search_data = search_response.json()
+            # Check if search was successful
+            if not search_data.get("status") or search_data.get("errorId") != "Success":
+                self.logger.warning("RapidAPI search failed")
+                return None
+            track_id = search_data.get("id")
+            if not track_id:
+                self.logger.warning("No track ID found in RapidAPI search results")
+                return None
+            self.logger.debug(f"Found track ID: {track_id}")
+            # Step 2: Fetch lyrics using the track ID
+            lyrics_url = "https://spotify-scraper.p.rapidapi.com/v1/track/lyrics"
+            lyrics_params = {
+                "trackId": track_id,
+                "format": "json",
+                "removeNote": "true"
+            }
+            self.logger.debug(f"Making RapidAPI lyrics request for track ID {track_id}")
+            lyrics_response = requests.get(lyrics_url, headers=headers, params=lyrics_params, timeout=10)
+            lyrics_response.raise_for_status()
+            lyrics_data = lyrics_response.json()
+            # Create a clean RapidAPI response structure
+            rapidapi_response = {
+                "track_data": search_data,
+                "lyrics_data": lyrics_data,
+                # Mark this as RapidAPI source
+                "_rapidapi_source": True
+            }
+            self.logger.info("Successfully fetched lyrics from RapidAPI")
+            return rapidapi_response
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"RapidAPI request failed: {str(e)}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error fetching from RapidAPI: {str(e)}")
+            return None
     def _convert_result_format(self, raw_data: Dict[str, Any]) -> LyricsData:
         """Convert Spotify's raw API response to standardized format."""
+        # Use our explicit source marker for detection
+        is_rapidapi = raw_data.get("_rapidapi_source", False)
+        if is_rapidapi:
+            return self._convert_rapidapi_format(raw_data)
+        else:
+            return self._convert_syrics_format(raw_data)
+    def _convert_syrics_format(self, raw_data: Dict[str, Any]) -> LyricsData:
+        """Convert syrics format to standardized format."""
         track_data = raw_data["track_data"]
         lyrics_data = raw_data["lyrics_data"]["lyrics"]
@@ -79,6 +164,7 @@ class SpotifyProvider(BaseLyricsProvider):
                 "preview_url": track_data.get("preview_url"),
                 "external_urls": track_data.get("external_urls"),
                 "sync_type": lyrics_data.get("syncType"),
+                "api_source": "syrics",
             },
         )
@@ -122,6 +208,80 @@ class SpotifyProvider(BaseLyricsProvider):
         return LyricsData(source="spotify", segments=segments, metadata=metadata)
+    def _convert_rapidapi_format(self, raw_data: Dict[str, Any]) -> LyricsData:
+        """Convert RapidAPI format to standardized format."""
+        track_data = raw_data["track_data"]
+        lyrics_data = raw_data["lyrics_data"]
+        # Extract artist names from RapidAPI format
+        artist_names = []
+        if "artists" in track_data:
+            artist_names = [artist.get("name", "") for artist in track_data["artists"]]
+        # Create metadata object
+        metadata = LyricsMetadata(
+            source="spotify",
+            track_name=track_data.get("name"),
+            artist_names=", ".join(artist_names),
+            album_name=track_data.get("album", {}).get("name"),
+            duration_ms=track_data.get("durationMs"),
+            explicit=track_data.get("explicit"),
+            is_synced=True,  # RapidAPI format includes timing information
+            lyrics_provider="spotify",
+            lyrics_provider_id=track_data.get("id"),
+            provider_metadata={
+                "spotify_id": track_data.get("id"),
+                "share_url": track_data.get("shareUrl"),
+                "duration_text": track_data.get("durationText"),
+                "album_cover": track_data.get("album", {}).get("cover"),
+                "api_source": "rapidapi",
+            },
+        )
+        # Create segments with timing information from RapidAPI format
+        segments = []
+        for line in lyrics_data:
+            if not line.get("text"):
+                continue
+            # Skip lines that are just musical notes
+            if not self._clean_lyrics(line["text"]):
+                continue
+            # Split line into words
+            word_texts = line["text"].strip().split()
+            if not word_texts:
+                continue
+            # Calculate timing for each word
+            start_time = float(line["startMs"]) / 1000 if line.get("startMs") else 0.0
+            duration = float(line["durMs"]) / 1000 if line.get("durMs") else 0.0
+            end_time = start_time + duration
+            word_duration = duration / len(word_texts)
+            words = []
+            for i, word_text in enumerate(word_texts):
+                word = Word(
+                    id=WordUtils.generate_id(),
+                    text=word_text,
+                    start_time=start_time + (i * word_duration),
+                    end_time=start_time + ((i + 1) * word_duration),
+                    confidence=1.0,
+                    created_during_correction=False,
+                )
+                words.append(word)
+            segment = LyricsSegment(
+                id=WordUtils.generate_id(),
+                text=line["text"].strip(),
+                words=words,
+                start_time=start_time,
+                end_time=end_time
+            )
+            segments.append(segment)
+        return LyricsData(source="spotify", segments=segments, metadata=metadata)
     def _clean_lyrics(self, lyrics: str) -> str:
         """Clean and process lyrics from Spotify to remove unwanted content."""
         # Remove lines that contain only musical note symbols

lyrics-transcriber 0.59.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

lyrics-transcriber 0.59.0py3-none-any.whl → 0.61.0py3-none-any.whl