lyrics-transcriber 0.20.0__py3-none-any.whl → 0.30.1__py3-none-any.whl

lyrics_transcriber/transcribers/whisper.py

@@ -0,0 +1,321 @@
+#! /usr/bin/env python3
+from dataclasses import dataclass
+import os
+import json
+import requests
+import hashlib
+import tempfile
+import time
+from typing import Optional, Dict, Any, Protocol, Union
+from pathlib import Path
+from pydub import AudioSegment
+from .base_transcriber import BaseTranscriber, TranscriptionData, LyricsSegment, Word, TranscriptionError
+
+
+@dataclass
+class WhisperConfig:
+    """Configuration for Whisper transcription service."""
+
+    runpod_api_key: Optional[str] = None
+    endpoint_id: Optional[str] = None
+    dropbox_app_key: Optional[str] = None
+    dropbox_app_secret: Optional[str] = None
+    dropbox_refresh_token: Optional[str] = None
+    timeout_minutes: int = 10
+
+
+class FileStorageProtocol(Protocol):
+    """Protocol for file storage operations."""
+
+    def file_exists(self, path: str) -> bool: ...  # pragma: no cover
+    def upload_with_retry(self, file: Any, path: str) -> None: ...  # pragma: no cover
+    def create_or_get_shared_link(self, path: str) -> str: ...  # pragma: no cover
+
+
+class RunPodWhisperAPI:
+    """Handles interactions with RunPod API."""
+
+    def __init__(self, config: WhisperConfig, logger):
+        self.config = config
+        self.logger = logger
+        self._validate_config()
+
+    def _validate_config(self) -> None:
+        """Validate API configuration."""
+        if not self.config.runpod_api_key or not self.config.endpoint_id:
+            raise ValueError("RunPod API key and endpoint ID must be provided")
+
+    def submit_job(self, audio_url: str) -> str:
+        """Submit transcription job and return job ID."""
+        run_url = f"https://api.runpod.ai/v2/{self.config.endpoint_id}/run"
+        headers = {"Authorization": f"Bearer {self.config.runpod_api_key}"}
+
+        payload = {
+            "input": {
+                "audio": audio_url,
+                "word_timestamps": True,
+                "model": "medium",
+                "temperature": 0.2,
+                "best_of": 5,
+                "compression_ratio_threshold": 2.8,
+                "no_speech_threshold": 1,
+                "condition_on_previous_text": True,
+                "enable_vad": True,
+            }
+        }
+
+        self.logger.info("Submitting transcription job...")
+        response = requests.post(run_url, json=payload, headers=headers)
+
+        self.logger.debug(f"Response status code: {response.status_code}")
+
+        # Try to parse and log the JSON response
+        try:
+            response_json = response.json()
+            self.logger.debug(f"Response content: {json.dumps(response_json, indent=2)}")
+        except ValueError:
+            self.logger.debug(f"Raw response content: {response.text}")
+            # Re-raise if we can't parse the response at all
+            raise TranscriptionError(f"Invalid JSON response: {response.text}")
+
+        response.raise_for_status()
+        return response_json["id"]
+
+    def get_job_status(self, job_id: str) -> Dict[str, Any]:
+        """Get job status and results."""
+        status_url = f"https://api.runpod.ai/v2/{self.config.endpoint_id}/status/{job_id}"
+        headers = {"Authorization": f"Bearer {self.config.runpod_api_key}"}
+
+        response = requests.get(status_url, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    def cancel_job(self, job_id: str) -> None:
+        """Cancel a running job."""
+        cancel_url = f"https://api.runpod.ai/v2/{self.config.endpoint_id}/cancel/{job_id}"
+        headers = {"Authorization": f"Bearer {self.config.runpod_api_key}"}
+
+        try:
+            response = requests.post(cancel_url, headers=headers)
+            response.raise_for_status()
+        except Exception as e:
+            self.logger.warning(f"Failed to cancel job {job_id}: {e}")
+
+    def wait_for_job_result(self, job_id: str) -> Dict[str, Any]:
+        """Poll for job completion and return results."""
+        self.logger.info(f"Getting job result for job {job_id}")
+
+        start_time = time.time()
+        last_status_log = start_time
+        timeout_seconds = self.config.timeout_minutes * 60
+
+        while True:
+            current_time = time.time()
+            elapsed_time = current_time - start_time
+
+            if elapsed_time > timeout_seconds:
+                self.cancel_job(job_id)
+                raise TranscriptionError(f"Transcription timed out after {self.config.timeout_minutes} minutes")
+
+            # Log status periodically
+            if current_time - last_status_log >= 60:
+                self.logger.info(f"Still waiting for transcription... Elapsed time: {int(elapsed_time/60)} minutes")
+                last_status_log = current_time
+
+            status_data = self.get_job_status(job_id)
+
+            if status_data["status"] == "COMPLETED":
+                return status_data["output"]
+            elif status_data["status"] == "FAILED":
+                error_msg = status_data.get("error", "Unknown error")
+                self.logger.error(f"Job failed with error: {error_msg}")
+                raise TranscriptionError(f"Transcription failed: {error_msg}")
+
+            time.sleep(5)
+
+
+class AudioProcessor:
+    """Handles audio file processing."""
+
+    def __init__(self, logger):
+        self.logger = logger
+
+    def get_file_md5(self, filepath: str) -> str:
+        """Calculate MD5 hash of a file."""
+        md5_hash = hashlib.md5()
+        with open(filepath, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                md5_hash.update(chunk)
+        return md5_hash.hexdigest()
+
+    def convert_to_flac(self, filepath: str) -> str:
+        """Convert WAV to FLAC if needed for faster upload."""
+        if not filepath.lower().endswith(".wav"):
+            return filepath
+
+        self.logger.info("Converting WAV to FLAC for faster upload...")
+        audio = AudioSegment.from_wav(filepath)
+
+        with tempfile.NamedTemporaryFile(suffix=".flac", delete=False) as temp_flac:
+            flac_path = temp_flac.name
+            audio.export(flac_path, format="flac")
+
+        return flac_path
+
+
+class WhisperTranscriber(BaseTranscriber):
+    """Transcription service using Whisper API via RunPod."""
+
+    def __init__(
+        self,
+        cache_dir: Union[str, Path],
+        config: Optional[WhisperConfig] = None,
+        logger: Optional[Any] = None,
+        runpod_client: Optional[RunPodWhisperAPI] = None,
+        storage_client: Optional[FileStorageProtocol] = None,
+        audio_processor: Optional[AudioProcessor] = None,
+    ):
+        """Initialize Whisper transcriber."""
+        super().__init__(cache_dir=cache_dir, logger=logger)
+
+        # Initialize configuration
+        self.config = config or WhisperConfig(
+            runpod_api_key=os.getenv("RUNPOD_API_KEY"),
+            endpoint_id=os.getenv("WHISPER_RUNPOD_ID"),
+            dropbox_app_key=os.getenv("WHISPER_DROPBOX_APP_KEY"),
+            dropbox_app_secret=os.getenv("WHISPER_DROPBOX_APP_SECRET"),
+            dropbox_refresh_token=os.getenv("WHISPER_DROPBOX_REFRESH_TOKEN"),
+        )
+
+        # Initialize components (with dependency injection)
+        self.runpod = runpod_client or RunPodWhisperAPI(self.config, self.logger)
+        self.storage = storage_client or self._initialize_storage()
+        self.audio_processor = audio_processor or AudioProcessor(self.logger)
+
+    def _initialize_storage(self) -> FileStorageProtocol:
+        """Initialize storage client."""
+        from ..storage.dropbox import DropboxHandler, DropboxConfig
+
+        # Create config using os.getenv directly
+        config = DropboxConfig(
+            app_key=os.getenv("WHISPER_DROPBOX_APP_KEY"),
+            app_secret=os.getenv("WHISPER_DROPBOX_APP_SECRET"),
+            refresh_token=os.getenv("WHISPER_DROPBOX_REFRESH_TOKEN"),
+        )
+
+        # Log the actual config values being used
+        self.logger.debug("Initializing DropboxHandler with config")
+        return DropboxHandler(config=config)
+
+    def get_name(self) -> str:
+        return "Whisper"
+
+    def _perform_transcription(self, audio_filepath: str) -> TranscriptionData:
+        """Actually perform the whisper transcription using Whisper API."""
+        self.logger.info(f"Starting transcription for {audio_filepath}")
+
+        # Start transcription and get results
+        job_id = self.start_transcription(audio_filepath)
+        result = self.get_transcription_result(job_id)
+        return result
+
+    def start_transcription(self, audio_filepath: str) -> str:
+        """Prepare audio and start whisper transcription job."""
+        audio_url, temp_filepath = self._prepare_audio_url(audio_filepath)
+        try:
+            return self.runpod.submit_job(audio_url)
+        except Exception as e:
+            if temp_filepath:
+                self._cleanup_temporary_files(temp_filepath)
+            raise TranscriptionError(f"Failed to submit job: {str(e)}") from e
+
+    def _prepare_audio_url(self, audio_filepath: str) -> tuple[str, Optional[str]]:
+        """Process audio file and return URL for API and path to any temporary files."""
+        if audio_filepath.startswith(("http://", "https://")):
+            return audio_filepath, None
+
+        file_hash = self.audio_processor.get_file_md5(audio_filepath)
+        temp_flac_filepath = self.audio_processor.convert_to_flac(audio_filepath)
+
+        # Upload and get URL
+        dropbox_path = f"/transcription_temp/{file_hash}{os.path.splitext(temp_flac_filepath)[1]}"
+        url = self._upload_and_get_link(temp_flac_filepath, dropbox_path)
+        return url, temp_flac_filepath
+
+    def get_transcription_result(self, job_id: str) -> Dict[str, Any]:
+        """Poll for whisper job completion and return raw results."""
+        raw_data = self.runpod.wait_for_job_result(job_id)
+
+        # Add job_id to raw data for later use
+        raw_data["job_id"] = job_id
+
+        return raw_data
+
+    def _convert_result_format(self, raw_data: Dict[str, Any]) -> TranscriptionData:
+        """Convert Whisper API response to standard format."""
+        self._validate_response(raw_data)
+
+        job_id = raw_data.get("job_id")
+        all_words = []
+
+        # First collect all words from word_timestamps
+        word_list = [
+            Word(
+                text=word["word"].strip(),
+                start_time=word["start"],
+                end_time=word["end"],
+                confidence=word.get("probability"),  # Only set if provided
+            )
+            for word in raw_data.get("word_timestamps", [])
+        ]
+        all_words.extend(word_list)
+
+        # Then create segments, using the words that fall within each segment's time range
+        segments = []
+        for seg in raw_data["segments"]:
+            segment_words = [word for word in word_list if seg["start"] <= word.start_time < seg["end"]]
+            segments.append(LyricsSegment(text=seg["text"].strip(), words=segment_words, start_time=seg["start"], end_time=seg["end"]))
+
+        return TranscriptionData(
+            segments=segments,
+            words=all_words,
+            text=raw_data["transcription"],
+            source=self.get_name(),
+            metadata={
+                "language": raw_data.get("detected_language", "en"),
+                "model": raw_data.get("model"),
+                "job_id": job_id,
+            },
+        )
+
+    def _upload_and_get_link(self, filepath: str, dropbox_path: str) -> str:
+        """Upload file to storage and return shared link."""
+        if not self.storage.file_exists(dropbox_path):
+            self.logger.info("Uploading file to storage...")
+            with open(filepath, "rb") as f:
+                self.storage.upload_with_retry(f, dropbox_path)
+        else:
+            self.logger.info("File already exists in storage, skipping upload...")
+
+        audio_url = self.storage.create_or_get_shared_link(dropbox_path)
+        self.logger.debug(f"Using shared link: {audio_url}")
+        return audio_url
+
+    def _cleanup_temporary_files(self, *filepaths: Optional[str]) -> None:
+        """Clean up any temporary files that were created during transcription."""
+        for filepath in filepaths:
+            if filepath and os.path.exists(filepath):
+                try:
+                    os.remove(filepath)
+                    self.logger.debug(f"Cleaned up temporary file: {filepath}")
+                except Exception as e:
+                    self.logger.warning(f"Failed to clean up temporary file {filepath}: {e}")
+
+    def _validate_response(self, raw_data: Dict[str, Any]) -> None:
+        """Validate the response contains required fields."""
+        if not isinstance(raw_data, dict):
+            raise TranscriptionError(f"Invalid response format: {raw_data}")
+        if "segments" not in raw_data:
+            raise TranscriptionError("Response missing required 'segments' field")
+        if "transcription" not in raw_data:
+            raise TranscriptionError("Response missing required 'transcription' field")

{lyrics_transcriber-0.20.0.dist-info → lyrics_transcriber-0.30.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lyrics-transcriber
-Version: 0.20.0
+Version: 0.30.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
 Home-page: https://github.com/karaokenerds/python-lyrics-transcriber
 License: MIT
@@ -13,24 +13,13 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: Cython (>=0)
-Requires-Dist: dtw-python (>=1)
-Requires-Dist: karaoke-lyrics-processor (>=0.4.1)
-Requires-Dist: llvmlite (>=0)
+Requires-Dist: dropbox (>=12)
+Requires-Dist: karaoke-lyrics-processor (>=0.4)
 Requires-Dist: lyricsgenius (>=3)
-Requires-Dist: numba (>=0.57)
-Requires-Dist: numpy (>=1)
-Requires-Dist: onnx (>=1)
-Requires-Dist: onnxruntime (>=1)
-Requires-Dist: openai (>=1,<2)
-Requires-Dist: openai-whisper (>=20231117)
+Requires-Dist: pydub (>=0.25)
+Requires-Dist: python-dotenv (>=1)
 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)
-Requires-Dist: whisper-timestamped (>=1)
 Project-URL: Documentation, https://github.com/karaokenerds/python-lyrics-transcriber/blob/main/README.md
 Project-URL: Repository, https://github.com/karaokenerds/python-lyrics-transcriber
 Description-Content-Type: text/markdown

lyrics_transcriber-0.30.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+lyrics_transcriber/__init__.py,sha256=Hj2HdSBAl6kmiqa5s3MDo_RobkITadzuF-81-ON3awA,180
+lyrics_transcriber/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/cli/cli_main.py,sha256=-h3W9E4P5lHEjIBWiDvY0v7avldhA-cfYoAVwMlv0Zo,8137
+lyrics_transcriber/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/core/controller.py,sha256=k_moklU2NqpHOGxWTRVyImWgX6_dv1NES0j50-FRGxw,13057
+lyrics_transcriber/correction/base_strategy.py,sha256=vEKsj19ZNZZkvHRP0J7cZamJWqjLZHbRJ9sN0AyHbAA,867
+lyrics_transcriber/correction/corrector.py,sha256=lsXJ1l5sNoZjIU65A3yWTXkOcraz7QP9KU8OUzA_UTc,2147
+lyrics_transcriber/correction/strategy_diff.py,sha256=xJTFnmVcuE18zZcitweVaRqB82jCMm9Ey29zAFB4LsI,10188
+lyrics_transcriber/lyrics/base_lyrics_provider.py,sha256=s5IDrlT6OudAA_gIlAQzeD0bPqoUFsiYftSQQm7XxOE,7518
+lyrics_transcriber/lyrics/genius.py,sha256=zDiv0t2f7wphnPdcyPH6tahXBfOnbE63Nu8eRG0nqg4,3195
+lyrics_transcriber/lyrics/spotify.py,sha256=Sic3nPFcpSWW7lE-yr3stb6D5m5WFSQXCwzWj3lW0Ls,3584
+lyrics_transcriber/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lyrics_transcriber/output/ass.py,sha256=b8lnjgXGD1OD1ld_b1xxUmSOf4nSEfz9BpgSkh16R4g,90291
+lyrics_transcriber/output/generator.py,sha256=idUsuS01bnaIB5spDFZlxE0wsvJ2I071SmJfXO9BCCk,10870
+lyrics_transcriber/output/subtitles.py,sha256=JEehSPl81hxhK6cS6RK4XAC_OLentCxiMCE7UYI9B64,11851
+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=0sXvD1FJYXxISH72n5HaN9fnTxgmaQrqmY1W5Lb6Yu8,8631
+lyrics_transcriber/transcribers/base_transcriber.py,sha256=9XWUlBSwBCjKvz7Gs1NT7EIysMyacS-YlvDjpwlqwgI,6985
+lyrics_transcriber/transcribers/whisper.py,sha256=QE9Dsb6emGOaFcepJHrECjVdCfAJZRncGj7uXy-0mAk,12942
+lyrics_transcriber-0.30.1.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
+lyrics_transcriber-0.30.1.dist-info/METADATA,sha256=c6P3R-KVxCJ10m-92bezeetdztdB7vvv5RMlTnF4Xbg,5485
+lyrics_transcriber-0.30.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+lyrics_transcriber-0.30.1.dist-info/entry_points.txt,sha256=KHZMIwodpv7TQUN9z28G-0knEFsRta9ZBAcIbmBAT40,75
+lyrics_transcriber-0.30.1.dist-info/RECORD,,

lyrics_transcriber-0.30.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+lyrics-transcriber=lyrics_transcriber.cli.cli_main:main
+

lyrics_transcriber/audioshake_transcriber.py

@@ -1,122 +0,0 @@
-import requests
-import time
-import os
-import json
-
-
-class AudioShakeTranscriber:
-    def __init__(self, api_token, logger, output_prefix):
-        self.api_token = api_token
-        self.base_url = "https://groovy.audioshake.ai"
-        self.logger = logger
-        self.output_prefix = output_prefix
-
-    def start_transcription(self, audio_filepath):
-        """Starts the transcription job and returns the job ID without waiting for completion"""
-        self.logger.info(f"Starting transcription for {audio_filepath} using AudioShake API")
-
-        # Step 1: Upload the audio file
-        asset_id = self._upload_file(audio_filepath)
-        self.logger.info(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.info(f"Job created successfully. Job ID: {job_id}")
-
-        return job_id
-
-    def get_transcription_result(self, job_id):
-        """Gets the results for a previously started job"""
-        self.logger.info(f"Getting results for 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.info(f"Job completed. Processing results...")
-
-        # Step 4: Process the result and return in the required format
-        return self._process_result(result)
-
-    def transcribe(self, audio_filepath):
-        """Original method now just combines the two steps"""
-        job_id = self.start_transcription(audio_filepath)
-        return self.get_transcription_result(job_id)
-
-    def _upload_file(self, filepath):
-        self.logger.info(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.info(f"Upload response status code: {response.status_code}")
-        self.logger.info(f"Upload response content: {response.text}")
-
-        response.raise_for_status()
-        return response.json()["id"]
-
-    def _create_job(self, asset_id):
-        self.logger.info(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.info(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['id']}")
-        self.logger.debug(f"Job data: {json.dumps(job_data, indent=2)}")
-
-        output_assets = job_data.get("outputAssets", [])
-        self.logger.debug(f"Output assets: {output_assets}")
-
-        output_asset = next((asset for asset in output_assets if asset["name"] == "alignment.json"), None)
-
-        if not output_asset:
-            self.logger.error("'alignment.json' found in job results")
-            self.logger.error(f"Available output assets: {[asset['name'] for asset in output_assets]}")
-            raise Exception("Required output not found in job results")
-
-        transcription_url = output_asset["link"]
-        self.logger.debug(f"Output URL: {transcription_url}")
-
-        response = requests.get(transcription_url)
-        response.raise_for_status()
-        transcription_data = response.json()
-        self.logger.debug(f"Output data: {json.dumps(transcription_data, indent=2)}")
-
-        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"])
-
-        transcription_data["output_filename"] = self.get_output_filename(" (AudioShake)")
-
-        return transcription_data
-
-    def get_output_filename(self, suffix):
-        """Generate consistent filename with (Purpose) suffix pattern"""
-        return f"{self.output_prefix}{suffix}"

lyrics_transcriber/corrector.py

@@ -1,57 +0,0 @@
-import json
-import logging
-from openai import OpenAI
-from typing import Dict, Optional
-
-
-class LyricsTranscriptionCorrector:
-    def __init__(
-        self,
-        logger: Optional[logging.Logger] = None,
-    ):
-        self.logger = logger or logging.getLogger(__name__)
-
-        # Initialize instance variables for input data
-        self.spotify_lyrics_data_dict = None
-        self.spotify_lyrics_text = None
-        self.genius_lyrics_text = None
-        self.transcription_data_dict_whisper = None
-        self.transcription_data_dict_audioshake = None
-
-    def set_input_data(
-        self,
-        spotify_lyrics_data_dict: Optional[Dict] = None,
-        spotify_lyrics_text: Optional[str] = None,
-        genius_lyrics_text: Optional[str] = None,
-        transcription_data_dict_whisper: Optional[Dict] = None,
-        transcription_data_dict_audioshake: Optional[Dict] = None,
-    ) -> None:
-        """Store the input data as instance variables"""
-        self.spotify_lyrics_data_dict = spotify_lyrics_data_dict
-        self.spotify_lyrics_text = spotify_lyrics_text
-        self.genius_lyrics_text = genius_lyrics_text
-        self.transcription_data_dict_whisper = transcription_data_dict_whisper
-        self.transcription_data_dict_audioshake = transcription_data_dict_audioshake
-
-    def run_corrector(self) -> Dict:
-        """
-        Test implementation that replaces every third word with 'YOLO' in the AudioShake transcription.
-        """
-        self.logger.info("Running corrector (test implementation - replacing every 3rd word with YOLO)")
-
-        # Create a deep copy to avoid modifying the original
-        modified_data = json.loads(json.dumps(self.transcription_data_dict_audioshake))
-
-        # Process each segment
-        for segment in modified_data["segments"]:
-            # Replace every third word in the words list
-            for i in range(2, len(segment["words"]), 3):
-                segment["words"][i]["text"] = "YOLO"
-
-            # Reconstruct the segment text from the modified words
-            segment["text"] = " ".join(word["text"] for word in segment["words"])
-
-        # Reconstruct the full text from all segments
-        modified_data["text"] = "".join(segment["text"] for segment in modified_data["segments"])
-
-        return modified_data

lyrics_transcriber/llm_prompts/README.md

@@ -1,10 +0,0 @@
-To get started, set your OPENAI_API_KEY environment variable.
-
-Next, edit promptfooconfig.yaml.
-
-Then run:
-```
-promptfoo eval
-```
-
-Afterwards, you can view the results by running `promptfoo view`

lyrics_transcriber/llm_prompts/llm_prompt_lyrics_correction_andrew_handwritten_20231118.txt

@@ -1,55 +0,0 @@
-You are a song lyric corrector for a karaoke video studio, responsible for reading lyrics inputs, correcting them and generating JSON-based responses containing the corrected lyrics according to predefined criteria. 
-Your task is to take two lyrics data inputs with two different qualities, and use the data in one to correct the other, producing accurate lyrics which align with roughly correct timestamps in the song.
-
-Your response needs to be in JSON format and will be sent to an API endpoint. Only output the JSON, nothing else, as the response will be converted to a Python dictionary.
-
-You will be provided with reference lyrics for the song, as plain text, from an online source.
-These should be reasonably accurate, with generally correct words and phrases. 
-However, they may not be perfect, and sometimes whole sections (such as a chorus or outro) may be missing or assumed to be repeated.
-
-Data input will contain one segment of an automated machine transcription of lyrics from a song, with start/end timestamps and confidence scores for every word in that segment.
-The timestamps for words are usually quite accurate, but the actual words which were heard by the transcription are typically only around 70% to 90% accurate.
-As such, it is common for there to be segments where most of the words are correct but one or two are wrong, or a single word may have been mistaken as two different words.
-
-When possible, you will also be provided with the previous 2 (corrected) lines of text, and the next 1 (un-corrected) segment text, for additional context.
-
-Carefully analyse the segment in the data input, and compare with the lyrics in the reference data, attempting to find part of the lyrics which is most likely to correspond with this segment.
-If all of the words match up correctly with words in the published lyrics, keep the entire segment from the transcription (do NOT add any additional words).
-If most of the words match up but one or two words are different (e.g. similar sounding words), correct those words.
-If there are symbols in the published lyrics, add those symbols to the closest word in the segment (NOT as a separate word). For example, parentheses are commonly used around backing vocals.
-If you need to delete a word or two in order to correct the lyrics, that's acceptable.
-
-Important: segments might not start and end at the same point as a "line" in the published lyrics, as the decision about where to split up a line into two is highly subjective.
-For example, in some published lyrics a line might be split in two (with a newline) before the word "and", but in another lyrics text that might only be one line.
-You will likely encounter situations where the words in the segment match part of the words in a published lyrics line, but not the whole line.
-
-Important: adding more words to the transcribed segment is usually not correct and should be the last resort!
-Remember, the goal is to correct mistakes (e.g. single words which were mis-heard) in the transcription rather than complete incomplete lines.
-Pay close attention to the "Context: Next (un-corrected) transcript segment" text, if this includes some of the words do NOT add those words to the current segment as this will cause duplication!
-
-The response JSON object needs to contain all of the following fields:
-
-- id: The id of the segment, from the data input
-- text: The full text of the corrected lyrics for this segment
-- words: this is a list
-  - text: The correct word
-  - start: The start timestamp for this word, estimated if not known for sure.
-  - end: The end timestamp for this word, estimated if not known for sure.
-  - confidence: Your self-assessed confidence score (from 0 to 1) of how likely it is that this word is accurate. If the word has not changed from the data input, keep the existing confidence value.
-
-Reference lyrics:
-
-{{reference_lyrics}}
-
-Previous two corrected lines:
-
-{{previous_two_corrected_lines}}
-
-Upcoming two uncorrected lines:
-
-{{upcoming_two_uncorrected_lines}}
-
-Data input:
-
-{{segment_input}}
-