lyrics-transcriber 0.16.3__tar.gz → 0.17.0__tar.gz

{lyrics_transcriber-0.16.3 → lyrics_transcriber-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lyrics-transcriber
-Version: 0.16.3
+Version: 0.17.0
 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
@@ -26,6 +26,7 @@ Requires-Dist: openai (>=1,<2)
 Requires-Dist: openai-whisper (>=20231117)
 Requires-Dist: python-slugify (>=8)
 Requires-Dist: syrics (>=0)
+Requires-Dist: tenacity (>=8)
 Requires-Dist: torch (>=1)
 Requires-Dist: tqdm (>=4)
 Requires-Dist: transformers (>=4)

lyrics_transcriber-0.17.0/lyrics_transcriber/audioshake_transcriber.py

@@ -0,0 +1,93 @@
+import requests
+import time
+import os
+import json
+
+
+class AudioShakeTranscriber:
+    def __init__(self, api_token, logger):
+        self.api_token = api_token
+        self.base_url = "https://groovy.audioshake.ai"
+        self.logger = logger
+
+    def transcribe(self, audio_filepath):
+        self.logger.info(f"Transcribing {audio_filepath} using AudioShake API")
+
+        # Step 1: Upload the audio file
+        asset_id = self._upload_file(audio_filepath)
+        self.logger.debug(f"File uploaded successfully. Asset ID: {asset_id}")
+
+        # Step 2: Create a job for transcription and alignment
+        job_id = self._create_job(asset_id)
+        self.logger.debug(f"Job created successfully. Job ID: {job_id}")
+
+        # Step 3: Wait for the job to complete and get the results
+        result = self._get_job_result(job_id)
+        self.logger.debug(f"Job completed. Processing results...")
+
+        # Step 4: Process the result and return in the required format
+        return self._process_result(result)
+
+    def _upload_file(self, filepath):
+        self.logger.debug(f"Uploading {filepath} to AudioShake")
+        url = f"{self.base_url}/upload"
+        headers = {"Authorization": f"Bearer {self.api_token}"}
+        with open(filepath, "rb") as file:
+            files = {"file": (os.path.basename(filepath), file)}
+            response = requests.post(url, headers=headers, files=files)
+
+        self.logger.debug(f"Upload response status code: {response.status_code}")
+        self.logger.debug(f"Upload response content: {response.text}")
+
+        response.raise_for_status()
+        return response.json()["id"]
+
+    def _create_job(self, asset_id):
+        self.logger.debug(f"Creating job for asset {asset_id}")
+        url = f"{self.base_url}/job/"
+        headers = {"Authorization": f"Bearer {self.api_token}", "Content-Type": "application/json"}
+        data = {
+            "metadata": {"format": "json", "name": "alignment", "language": "en"},
+            "callbackUrl": "https://example.com/webhook/alignment",
+            "assetId": asset_id,
+        }
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        return response.json()["job"]["id"]
+
+    def _get_job_result(self, job_id):
+        self.logger.debug(f"Getting job result for job {job_id}")
+        url = f"{self.base_url}/job/{job_id}"
+        headers = {"Authorization": f"Bearer {self.api_token}", "Content-Type": "application/json"}
+        while True:
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()
+            job_data = response.json()["job"]
+            if job_data["status"] == "completed":
+                return job_data
+            elif job_data["status"] == "failed":
+                raise Exception("Job failed")
+            time.sleep(5)  # Wait 5 seconds before checking again
+
+    def _process_result(self, job_data):
+        self.logger.debug(f"Processing result for job {job_data}")
+        output_asset = next((asset for asset in job_data["outputAssets"] if asset["name"] == "transcription.json"), None)
+
+        if not output_asset:
+            raise Exception("Transcription output not found in job results")
+
+        transcription_url = output_asset["link"]
+        response = requests.get(transcription_url)
+        response.raise_for_status()
+        transcription_data = response.json()
+
+        transcription_data = {"segments": transcription_data.get("lines", []), "text": transcription_data.get("text", "")}
+
+        # Ensure each segment has the required fields
+        for segment in transcription_data["segments"]:
+            if "words" not in segment:
+                segment["words"] = []
+            if "text" not in segment:
+                segment["text"] = " ".join(word["text"] for word in segment["words"])
+
+        return transcription_data

{lyrics_transcriber-0.16.3 → lyrics_transcriber-0.17.0}/lyrics_transcriber/transcriber.py

@@ -14,6 +14,8 @@ from datetime import timedelta
 from .utils import subtitles
 from typing import List, Optional
 from openai import OpenAI
+from tenacity import retry, stop_after_delay, wait_exponential, retry_if_exception_type
+import requests
 
 
 class LyricsTranscriber:
@@ -536,6 +538,16 @@ class LyricsTranscriber:
                     self.outputs["spotify_lyrics_text"] += line["words"].strip() + "\n"
                     f.write(line["words"].strip() + "\n")
 
+    @retry(
+        stop=stop_after_delay(120),  # Stop after 2 minutes
+        wait=wait_exponential(multiplier=1, min=4, max=60),  # Exponential backoff starting at 4 seconds
+        retry=retry_if_exception_type(requests.exceptions.RequestException),  # Retry on request exceptions
+        reraise=True,  # Reraise the last exception if all retries fail
+    )
+    def fetch_genius_lyrics(self, genius, title, artist):
+        self.logger.debug(f"fetch_genius_lyrics attempting to fetch lyrics from Genius for {title} by {artist}")
+        return genius.search_song(title, artist)
+
     def write_genius_lyrics_file(self):
         if self.genius_api_token and self.song_known:
             self.logger.debug(f"attempting genius fetch as genius_api_token and song name was set")
@@ -556,18 +568,22 @@ class LyricsTranscriber:
         self.logger.debug(f"no cached lyrics found at genius_lyrics_cache_filepath: {genius_lyrics_cache_filepath}, fetching from Genius")
         genius = lyricsgenius.Genius(self.genius_api_token, verbose=(self.log_level == logging.DEBUG))
 
-        song = genius.search_song(self.title, self.artist)
-        if song is None:
-            self.logger.warning(f'Could not find lyrics on Genius for "{self.title}" by {self.artist}')
-            return
-        lyrics = self.clean_genius_lyrics(song.lyrics)
+        try:
+            song = self.fetch_genius_lyrics(genius, self.title, self.artist)
+            if song is None:
+                self.logger.warning(f'Could not find lyrics on Genius for "{self.title}" by {self.artist}')
+                return
+            lyrics = self.clean_genius_lyrics(song.lyrics)
 
-        self.logger.debug(f"writing clean lyrics to genius_lyrics_cache_filepath: {genius_lyrics_cache_filepath}")
-        with open(genius_lyrics_cache_filepath, "w", encoding="utf-8") as f:
-            f.write(lyrics)
+            self.logger.debug(f"writing clean lyrics to genius_lyrics_cache_filepath: {genius_lyrics_cache_filepath}")
+            with open(genius_lyrics_cache_filepath, "w", encoding="utf-8") as f:
+                f.write(lyrics)
 
-        self.outputs["genius_lyrics_filepath"] = genius_lyrics_cache_filepath
-        self.outputs["genius_lyrics_text"] = lyrics
+            self.outputs["genius_lyrics_filepath"] = genius_lyrics_cache_filepath
+            self.outputs["genius_lyrics_text"] = lyrics
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Failed to fetch lyrics from Genius after multiple retries: {e}")
+            raise
 
     def clean_genius_lyrics(self, lyrics):
         lyrics = lyrics.replace("\\n", "\n")
@@ -928,10 +944,10 @@ class LyricsTranscriber:
         transcription_cache_suffix = "-audioshake" if self.audioshake_api_token else "-whisper"
         self.outputs["transcription_data_filepath"] = self.get_cache_filepath(f"{transcription_cache_suffix}.json")
 
-        whisper_cache_filepath = self.outputs["transcription_data_filepath"]
-        if os.path.isfile(whisper_cache_filepath):
-            self.logger.debug(f"transcribe found existing file at whisper_cache_filepath, reading: {whisper_cache_filepath}")
-            with open(whisper_cache_filepath, "r") as cache_file:
+        transcription_cache_filepath = self.outputs["transcription_data_filepath"]
+        if os.path.isfile(transcription_cache_filepath):
+            self.logger.debug(f"transcribe found existing file at transcription_cache_filepath, reading: {transcription_cache_filepath}")
+            with open(transcription_cache_filepath, "r") as cache_file:
                 self.outputs["transcription_data_dict"] = json.load(cache_file)
                 return
 
@@ -939,28 +955,28 @@ class LyricsTranscriber:
             self.logger.debug(f"Using AudioShake API for transcription")
             from .audioshake_transcriber import AudioShakeTranscriber
 
-            audioshake = AudioShakeTranscriber(self.audioshake_api_token, log_level=self.log_level)
-            result = audioshake.transcribe(self.audio_filepath)
+            audioshake = AudioShakeTranscriber(self.audioshake_api_token, logger=self.logger)
+            transcription_data = audioshake.transcribe(self.audio_filepath)
         else:
             self.logger.debug(f"Using Whisper for transcription with model: {self.transcription_model}")
             audio = whisper.load_audio(self.audio_filepath)
             model = whisper.load_model(self.transcription_model, device="cpu")
-            result = whisper.transcribe(model, audio, language="en", vad="auditok", beam_size=5, temperature=0.2, best_of=5)
+            transcription_data = whisper.transcribe(model, audio, language="en", vad="auditok", beam_size=5, temperature=0.2, best_of=5)
 
             # Remove segments with no words, only music
-            result["segments"] = [segment for segment in result["segments"] if segment["text"].strip() != "Music"]
-            self.logger.debug(f"Removed 'Music' segments. Remaining segments: {len(result['segments'])}")
+            transcription_data["segments"] = [segment for segment in transcription_data["segments"] if segment["text"].strip() != "Music"]
+            self.logger.debug(f"Removed 'Music' segments. Remaining segments: {len(transcription_data['segments'])}")
 
             # Split long segments
             self.logger.debug("Starting to split long segments")
-            result["segments"] = self.split_long_segments(result["segments"], max_length=36)
-            self.logger.debug(f"Finished splitting segments. Total segments after splitting: {len(result['segments'])}")
+            transcription_data["segments"] = self.split_long_segments(transcription_data["segments"], max_length=36)
+            self.logger.debug(f"Finished splitting segments. Total segments after splitting: {len(transcription_data['segments'])}")
 
-        self.logger.debug(f"writing transcription data JSON to cache file: {whisper_cache_filepath}")
-        with open(whisper_cache_filepath, "w") as cache_file:
-            json.dump(result, cache_file, indent=4)
+        self.logger.debug(f"writing transcription data JSON to cache file: {transcription_cache_filepath}")
+        with open(transcription_cache_filepath, "w") as cache_file:
+            json.dump(transcription_data, cache_file, indent=4)
 
-        self.outputs["transcription_data_dict"] = result
+        self.outputs["transcription_data_dict"] = transcription_data
 
     def get_cache_filepath(self, extension):
         filename = os.path.split(self.audio_filepath)[1]

{lyrics_transcriber-0.16.3 → lyrics_transcriber-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "lyrics-transcriber"
-version = "0.16.3"
+version = "0.17.0"
 description = "Automatically create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps, using Whisper and lyrics from Genius and Spotify"
 authors = ["Andrew Beveridge <andrew@beveridge.uk>"]
 license = "MIT"
@@ -30,6 +30,7 @@ openai-whisper = ">=20231117"
 transformers = ">=4"
 auditok = ">=0.2"
 whisper-timestamped = ">=1"
+tenacity = ">=8"
 # Note: after adding openai-whisper and whisper-timestamped with poetry lock, I then removed all traces of triton
 # from poetry.lock before running poetry install, as triton doesn't support macOS but isn't actually needed for whisper.
 # This was the only way I was able to get a working cross-platform build published to PyPI.
@@ -47,4 +48,4 @@ lyrics-transcriber = 'lyrics_transcriber.utils.cli:main'
 
 [build-system]
 requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+build-backend = "poetry.core.masonry.api"

lyrics_transcriber-0.16.3/lyrics_transcriber/audioshake_transcriber.py

@@ -1,35 +0,0 @@
-import logging
-import requests
-
-
-class AudioShakeTranscriber:
-    def __init__(self, api_token, log_level=logging.DEBUG):
-        self.api_token = api_token
-        self.logger = logging.getLogger(__name__)
-        self.logger.setLevel(log_level)
-
-    def transcribe(self, audio_filepath):
-        # This is a placeholder for the actual AudioShake API implementation
-        self.logger.info(f"Transcribing {audio_filepath} using AudioShake API")
-
-        self.logger.debug(f"AudioShake API token: {self.api_token}")
-        # TODO: Implement the actual API call to AudioShake
-        # For now, we'll return a dummy result
-        return {
-            "transcription_data_dict": {
-                "segments": [
-                    {
-                        "start": 0,
-                        "end": 5,
-                        "text": "This is a dummy transcription",
-                        "words": [
-                            {"text": "This", "start": 0, "end": 1},
-                            {"text": "is", "start": 1, "end": 2},
-                            {"text": "a", "start": 2, "end": 3},
-                            {"text": "dummy", "start": 3, "end": 4},
-                            {"text": "transcription", "start": 4, "end": 5},
-                        ],
-                    }
-                ]
-            }
-        }