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

lyrics_transcriber/output/generator.py

@@ -0,0 +1,210 @@
+import os
+import logging
+from typing import Dict, Any, Optional
+import subprocess
+from datetime import timedelta
+from .subtitles import create_styled_subtitles, LyricsScreen, LyricsLine, LyricSegment
+
+
+class OutputGenerator:
+    """Handles generation of various lyrics output formats."""
+
+    def __init__(
+        self,
+        logger: Optional[logging.Logger] = None,
+        output_dir: Optional[str] = None,
+        cache_dir: str = "/tmp/lyrics-transcriber-cache/",
+        video_resolution: str = "360p",
+        video_background_image: Optional[str] = None,
+        video_background_color: str = "black",
+    ):
+        self.logger = logger or logging.getLogger(__name__)
+        self.output_dir = output_dir
+        self.cache_dir = cache_dir
+
+        # Video settings
+        self.video_resolution = video_resolution
+        self.video_background_image = video_background_image
+        self.video_background_color = video_background_color
+
+        # Set video resolution parameters
+        self.video_resolution_num, self.font_size, self.line_height = self._get_video_params(video_resolution)
+
+        # Validate video background if provided
+        if self.video_background_image and not os.path.isfile(self.video_background_image):
+            raise FileNotFoundError(f"Video background image not found: {self.video_background_image}")
+
+    def generate_outputs(
+        self, transcription_data: Dict[str, Any], output_prefix: str, audio_filepath: str, render_video: bool = False
+    ) -> Dict[str, str]:
+        """
+        Generate all requested output formats.
+
+        Args:
+            transcription_data: Dictionary containing transcription segments with timing
+            output_prefix: Prefix for output filenames
+            audio_filepath: Path to the source audio file
+            render_video: Whether to generate video output
+
+        Returns:
+            Dictionary of output paths for each format
+        """
+        outputs = {}
+
+        try:
+            # Generate LRC
+            lrc_path = self.generate_lrc(transcription_data, output_prefix)
+            outputs["lrc"] = lrc_path
+
+            # Generate ASS
+            ass_path = self.generate_ass(transcription_data, output_prefix)
+            outputs["ass"] = ass_path
+
+            # Generate video if requested
+            if render_video:
+                video_path = self.generate_video(ass_path, audio_filepath, output_prefix)
+                outputs["video"] = video_path
+
+        except Exception as e:
+            self.logger.error(f"Error generating outputs: {str(e)}")
+            raise
+
+        return outputs
+
+    def generate_lrc(self, transcription_data: Dict[str, Any], output_prefix: str) -> str:
+        """Generate LRC format lyrics file."""
+        self.logger.info("Generating LRC format lyrics")
+
+        output_path = os.path.join(self.output_dir or self.cache_dir, f"{output_prefix}.lrc")
+
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                for segment in transcription_data["segments"]:
+                    start_time = self._format_lrc_timestamp(segment["start"])
+                    line = f"[{start_time}]{segment['text']}\n"
+                    f.write(line)
+
+            self.logger.info(f"LRC file generated: {output_path}")
+            return output_path
+
+        except Exception as e:
+            self.logger.error(f"Failed to generate LRC file: {str(e)}")
+            raise
+
+    def generate_ass(self, transcription_data: Dict[str, Any], output_prefix: str) -> str:
+        """Generate ASS format subtitles file."""
+        self.logger.info("Generating ASS format subtitles")
+
+        output_path = os.path.join(self.output_dir or self.cache_dir, f"{output_prefix}.ass")
+
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                # Write ASS header
+                f.write(self._get_ass_header())
+
+                # Write events
+                for segment in transcription_data["segments"]:
+                    start_time = self._format_ass_timestamp(segment["start"])
+                    end_time = self._format_ass_timestamp(segment["end"])
+                    line = f"Dialogue: 0,{start_time},{end_time},Default,,0,0,0,,{segment['text']}\n"
+                    f.write(line)
+
+            self.logger.info(f"ASS file generated: {output_path}")
+            return output_path
+
+        except Exception as e:
+            self.logger.error(f"Failed to generate ASS file: {str(e)}")
+            raise
+
+    def generate_video(self, ass_path: str, audio_path: str, output_prefix: str) -> str:
+        """Generate MP4 video with lyrics overlay."""
+        self.logger.info("Generating video with lyrics overlay")
+
+        output_path = os.path.join(self.output_dir or self.cache_dir, f"{output_prefix}.mp4")
+        width, height = self.video_resolution_num
+
+        try:
+            # Prepare FFmpeg command
+            cmd = [
+                "ffmpeg",
+                "-y",
+                "-f",
+                "lavfi",
+                "-i",
+                f"color=c={self.video_background_color}:s={width}x{height}",
+                "-i",
+                audio_path,
+                "-vf",
+                f"ass={ass_path}",
+                "-c:v",
+                "libx264",
+                "-c:a",
+                "aac",
+                "-shortest",
+                output_path,
+            ]
+
+            # If background image provided, use it instead of solid color
+            if self.video_background_image:
+                cmd[3:6] = ["-i", self.video_background_image]
+
+            self.logger.debug(f"Running FFmpeg command: {' '.join(cmd)}")
+            subprocess.run(cmd, check=True)
+
+            self.logger.info(f"Video generated: {output_path}")
+            return output_path
+
+        except subprocess.CalledProcessError as e:
+            self.logger.error(f"FFmpeg error: {str(e)}")
+            raise
+        except Exception as e:
+            self.logger.error(f"Failed to generate video: {str(e)}")
+            raise
+
+    def _get_video_params(self, resolution: str) -> tuple:
+        """Get video parameters based on resolution setting."""
+        match resolution:
+            case "4k":
+                return (3840, 2160), 250, 250
+            case "1080p":
+                return (1920, 1080), 120, 120
+            case "720p":
+                return (1280, 720), 100, 100
+            case "360p":
+                return (640, 360), 50, 50
+            case _:
+                raise ValueError("Invalid video_resolution value. Must be one of: 4k, 1080p, 720p, 360p")
+
+    def _format_lrc_timestamp(self, seconds: float) -> str:
+        """Format timestamp for LRC format."""
+        time = timedelta(seconds=seconds)
+        minutes = int(time.total_seconds() / 60)
+        seconds = time.total_seconds() % 60
+        return f"{minutes:02d}:{seconds:05.2f}"
+
+    def _format_ass_timestamp(self, seconds: float) -> str:
+        """Format timestamp for ASS format."""
+        time = timedelta(seconds=seconds)
+        hours = int(time.total_seconds() / 3600)
+        minutes = int((time.total_seconds() % 3600) / 60)
+        seconds = time.total_seconds() % 60
+        centiseconds = int((seconds % 1) * 100)
+        seconds = int(seconds)
+        return f"{hours}:{minutes:02d}:{seconds:02d}.{centiseconds:02d}"
+
+    def _get_ass_header(self) -> str:
+        """Get ASS format header with style definitions."""
+        width, height = self.video_resolution_num
+        return f"""[Script Info]
+ScriptType: v4.00+
+PlayResX: {width}
+PlayResY: {height}
+WrapStyle: 0
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Arial,{self.font_size},&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,2,2,10,10,10,1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+"""

lyrics_transcriber/storage/dropbox.py

@@ -0,0 +1,249 @@
+import dropbox
+from dropbox import Dropbox
+from dropbox.files import WriteMode
+import os
+import time
+import logging
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class DropboxHandler:
+    def __init__(self, app_key=None, app_secret=None, refresh_token=None, access_token=None):
+        self.app_key = app_key or os.environ.get("WHISPER_DROPBOX_APP_KEY")
+        self.app_secret = app_secret or os.environ.get("WHISPER_DROPBOX_APP_SECRET")
+        self.refresh_token = refresh_token or os.environ.get("WHISPER_DROPBOX_REFRESH_TOKEN")
+        self.access_token = access_token or os.environ.get("WHISPER_DROPBOX_ACCESS_TOKEN")
+        self.dbx = Dropbox(self.access_token)
+
+    def _refresh_access_token(self):
+        """Refresh the access token using the refresh token."""
+        try:
+            logger.debug("Attempting to refresh access token")
+            # Prepare the token refresh request
+            data = {"grant_type": "refresh_token", "refresh_token": self.refresh_token}
+            auth = (self.app_key, self.app_secret)
+
+            logger.debug(f"Making refresh token request to Dropbox API")
+            response = requests.post("https://api.dropbox.com/oauth2/token", data=data, auth=auth)
+
+            logger.debug(f"Received response from Dropbox API. Status code: {response.status_code}")
+            if response.status_code == 200:
+                result = response.json()
+                self.access_token = result["access_token"]
+                self.dbx = Dropbox(self.access_token)
+                logger.info("Successfully refreshed access token")
+            else:
+                logger.error(f"Failed to refresh token. Status code: {response.status_code}, Response: {response.text}")
+
+        except Exception as e:
+            logger.error(f"Error refreshing access token: {str(e)}", exc_info=True)
+            raise
+
+    @staticmethod
+    def _handle_auth_error(func):
+        """Decorator to handle authentication errors and retry with refreshed token."""
+
+        def wrapper(self, *args, **kwargs):
+            try:
+                logger.debug(f"Executing {func.__name__} with args: {args}, kwargs: {kwargs}")
+                return func(self, *args, **kwargs)
+            except (dropbox.exceptions.AuthError, dropbox.exceptions.ApiError) as e:
+                logger.debug(f"Caught error in {func.__name__}: {str(e)}")
+                if "expired_access_token" in str(e):
+                    logger.info(f"Access token expired in {func.__name__}, attempting refresh")
+                    self._refresh_access_token()
+                    logger.debug(f"Retrying {func.__name__} after token refresh")
+                    return func(self, *args, **kwargs)
+                logger.error(f"Unhandled Dropbox error in {func.__name__}: {str(e)}")
+                raise
+
+        return wrapper
+
+    @_handle_auth_error
+    def upload_with_retry(self, file, path, max_retries=3):
+        """Upload a file to Dropbox with retries."""
+        for attempt in range(max_retries):
+            try:
+                logger.debug(f"Attempting file upload to {path} (attempt {attempt + 1}/{max_retries})")
+                file.seek(0)
+                self.dbx.files_upload(file.read(), path, mode=WriteMode.overwrite)
+                logger.debug(f"Successfully uploaded file to {path}")
+                return
+            except dropbox.exceptions.ApiError as e:
+                logger.warning(f"Upload attempt {attempt + 1} failed: {str(e)}")
+                if attempt == max_retries - 1:
+                    logger.error(f"All upload attempts failed for {path}: {str(e)}")
+                    raise
+                sleep_time = 1 * (attempt + 1)
+                logger.debug(f"Waiting {sleep_time} seconds before retry")
+                time.sleep(sleep_time)
+
+    @_handle_auth_error
+    def upload_string_with_retry(self, content, path, max_retries=3):
+        """Upload a string content to Dropbox with retries."""
+        for attempt in range(max_retries):
+            try:
+                logger.debug(f"Attempting string upload to {path} (attempt {attempt + 1}/{max_retries})")
+                self.dbx.files_upload(content.encode(), path, mode=WriteMode.overwrite)
+                logger.debug(f"Successfully uploaded string content to {path}")
+                return
+            except dropbox.exceptions.ApiError as e:
+                logger.warning(f"Upload attempt {attempt + 1} failed: {str(e)}")
+                if attempt == max_retries - 1:
+                    logger.error(f"All upload attempts failed for {path}: {str(e)}")
+                    raise
+                sleep_time = 1 * (attempt + 1)
+                logger.debug(f"Waiting {sleep_time} seconds before retry")
+                time.sleep(sleep_time)
+
+    @_handle_auth_error
+    def list_folder_recursive(self, path=""):
+        """List all files in a folder recursively."""
+        try:
+            logger.debug(f"Listing files recursively from {path}")
+            entries = []
+            result = self.dbx.files_list_folder(path, recursive=True)
+
+            while True:
+                entries.extend(result.entries)
+                if not result.has_more:
+                    break
+                logger.debug("Fetching more results from Dropbox")
+                result = self.dbx.files_list_folder_continue(result.cursor)
+
+            return entries
+
+        except (dropbox.exceptions.AuthError, dropbox.exceptions.ApiError):
+            # Let the decorator handle these
+            raise
+        except Exception as e:
+            logger.error(f"Error listing files from Dropbox: {str(e)}", exc_info=True)
+            raise
+
+    @_handle_auth_error
+    def download_file_content(self, path):
+        """Download and return the content of a file."""
+        try:
+            logger.debug(f"Downloading file content from {path}")
+            return self.dbx.files_download(path)[1].content
+        except Exception as e:
+            logger.error(f"Error downloading file from {path}: {str(e)}", exc_info=True)
+            raise
+
+    @_handle_auth_error
+    def download_folder(self, dropbox_path, local_path):
+        """Download all files from a Dropbox folder to a local path."""
+        try:
+            logger.debug(f"Downloading folder {dropbox_path} to {local_path}")
+
+            # List all files in the folder
+            result = self.dbx.files_list_folder(dropbox_path, recursive=True)
+            entries = result.entries
+
+            # Continue fetching if there are more files
+            while result.has_more:
+                result = self.dbx.files_list_folder_continue(result.cursor)
+                entries.extend(result.entries)
+
+            # Download each file
+            for entry in entries:
+                if isinstance(entry, dropbox.files.FileMetadata):
+                    # Calculate relative path from the root folder
+                    rel_path = entry.path_display[len(dropbox_path) :].lstrip("/")
+                    local_file_path = os.path.join(local_path, rel_path)
+
+                    # Create directories if they don't exist
+                    os.makedirs(os.path.dirname(local_file_path), exist_ok=True)
+
+                    # Download the file
+                    logger.debug(f"Downloading {entry.path_display} to {local_file_path}")
+                    self.dbx.files_download_to_file(local_file_path, entry.path_display)
+
+            logger.debug(f"Successfully downloaded folder {dropbox_path} to {local_path}")
+
+        except Exception as e:
+            logger.error(f"Error downloading folder {dropbox_path}: {str(e)}", exc_info=True)
+            raise
+
+    @_handle_auth_error
+    def upload_folder(self, local_path, dropbox_path):
+        """Upload all files from a local folder to a Dropbox path."""
+        try:
+            logger.debug(f"Uploading folder {local_path} to {dropbox_path}")
+
+            # Walk through all files in the local folder
+            for root, dirs, files in os.walk(local_path):
+                for filename in files:
+                    local_file_path = os.path.join(root, filename)
+                    # Calculate relative path from local_path
+                    rel_path = os.path.relpath(local_file_path, local_path)
+                    target_path = f"{dropbox_path}/{rel_path}"
+
+                    logger.debug(f"Uploading {rel_path} to {target_path}")
+                    with open(local_file_path, "rb") as f:
+                        self.dbx.files_upload(f.read(), target_path, mode=WriteMode.overwrite)
+
+            logger.debug(f"Successfully uploaded folder {local_path} to {dropbox_path}")
+
+        except Exception as e:
+            logger.error(f"Error uploading folder {local_path}: {str(e)}", exc_info=True)
+            raise
+
+    @_handle_auth_error
+    def create_shared_link(self, path):
+        """Create a shared link for a file that's accessible without login."""
+        try:
+            logger.debug(f"Creating shared link for {path}")
+            shared_link = self.dbx.sharing_create_shared_link_with_settings(
+                path, settings=dropbox.sharing.SharedLinkSettings(requested_visibility=dropbox.sharing.RequestedVisibility.public)
+            )
+            # Convert dropbox shared link to direct download link
+            return shared_link.url.replace("www.dropbox.com", "dl.dropboxusercontent.com")
+        except Exception as e:
+            logger.error(f"Error creating shared link: {str(e)}", exc_info=True)
+            raise
+
+    @_handle_auth_error
+    def get_existing_shared_link(self, path):
+        """Get existing shared link for a file if it exists."""
+        try:
+            logger.debug(f"Getting existing shared link for {path}")
+            shared_links = self.dbx.sharing_list_shared_links(path=path).links
+            if shared_links:
+                # Convert to direct download link
+                return shared_links[0].url.replace("www.dropbox.com", "dl.dropboxusercontent.com")
+            return None
+        except Exception as e:
+            logger.error(f"Error getting existing shared link: {str(e)}", exc_info=True)
+            return None
+
+    @_handle_auth_error
+    def create_or_get_shared_link(self, path):
+        """Create a shared link or get existing one."""
+        try:
+            # First try to get existing link
+            existing_link = self.get_existing_shared_link(path)
+            if existing_link:
+                logger.debug(f"Found existing shared link for {path}")
+                return existing_link
+
+            # If no existing link, create new one
+            logger.debug(f"Creating new shared link for {path}")
+            shared_link = self.dbx.sharing_create_shared_link_with_settings(
+                path, settings=dropbox.sharing.SharedLinkSettings(requested_visibility=dropbox.sharing.RequestedVisibility.public)
+            )
+            return shared_link.url.replace("www.dropbox.com", "dl.dropboxusercontent.com")
+        except Exception as e:
+            logger.error(f"Error creating or getting shared link: {str(e)}", exc_info=True)
+            raise
+
+    @_handle_auth_error
+    def file_exists(self, path):
+        """Check if a file exists in Dropbox."""
+        try:
+            self.dbx.files_get_metadata(path)
+            return True
+        except:
+            return False

lyrics_transcriber/storage/tokens.py

@@ -0,0 +1,116 @@
+#! /usr/bin/env python3
+import http.server
+import socketserver
+import webbrowser
+import urllib.parse
+import requests
+from dotenv import load_dotenv
+import base64
+from threading import Thread
+import argparse
+
+# Load environment variables
+load_dotenv()
+
+REDIRECT_URL = "http://localhost:53682/"
+
+# Store the authorization code when received
+auth_code = None
+
+
+class OAuthHandler(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self):
+        global auth_code
+        # Parse the query parameters
+        query = urllib.parse.urlparse(self.path).query
+        params = urllib.parse.parse_qs(query)
+
+        if "code" in params:
+            auth_code = params["code"][0]
+            # Send success response
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"Authorization successful! You can close this window.")
+
+            # Shutdown the server
+            Thread(target=self.server.shutdown).start()
+        else:
+            # Handle error or other cases
+            self.send_response(400)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"Authorization failed!")
+
+
+def get_tokens(app_key, app_secret):
+    # Construct the authorization URL
+    auth_url = (
+        "https://www.dropbox.com/oauth2/authorize"
+        f"?client_id={app_key}"
+        f"&redirect_uri={REDIRECT_URL}"
+        "&response_type=code"
+        "&token_access_type=offline"
+    )
+
+    # Start local server
+    port = int(REDIRECT_URL.split(":")[-1].strip("/"))
+    httpd = socketserver.TCPServer(("", port), OAuthHandler)
+
+    print(f"Opening browser for Dropbox authorization...")
+    webbrowser.open(auth_url)
+
+    print(f"Waiting for authorization...")
+    httpd.serve_forever()
+
+    if auth_code:
+        print("Authorization code received, exchanging for tokens...")
+
+        # Exchange authorization code for tokens
+        auth = base64.b64encode(f"{app_key}:{app_secret}".encode()).decode()
+        response = requests.post(
+            "https://api.dropbox.com/oauth2/token",
+            data={"code": auth_code, "grant_type": "authorization_code", "redirect_uri": REDIRECT_URL},
+            headers={"Authorization": f"Basic {auth}"},
+        )
+
+        if response.status_code == 200:
+            tokens = response.json()
+            print("\nTokens received successfully!")
+            print("\nAdd these lines to your .env file:")
+            print(f"WHISPER_DROPBOX_APP_KEY={app_key}")
+            print(f"WHISPER_DROPBOX_APP_SECRET={app_secret}")
+            print(f"WHISPER_DROPBOX_ACCESS_TOKEN={tokens['access_token']}")
+            print(f"WHISPER_DROPBOX_REFRESH_TOKEN={tokens['refresh_token']}")
+
+            # Optionally update .env file directly
+            update = input("\nWould you like to update your .env file automatically? (y/n): ")
+            if update.lower() == "y":
+                with open(".env", "r") as f:
+                    lines = f.readlines()
+
+                with open(".env", "w") as f:
+                    for line in lines:
+                        if line.startswith("WHISPER_DROPBOX_APP_KEY="):
+                            f.write(f"WHISPER_DROPBOX_APP_KEY={app_key}\n")
+                        elif line.startswith("WHISPER_DROPBOX_APP_SECRET="):
+                            f.write(f"WHISPER_DROPBOX_APP_SECRET={app_secret}\n")
+                        elif line.startswith("WHISPER_DROPBOX_ACCESS_TOKEN="):
+                            f.write(f"WHISPER_DROPBOX_ACCESS_TOKEN={tokens['access_token']}\n")
+                        elif line.startswith("WHISPER_DROPBOX_REFRESH_TOKEN="):
+                            f.write(f"WHISPER_DROPBOX_REFRESH_TOKEN={tokens['refresh_token']}\n")
+                        else:
+                            f.write(line)
+                print("Updated .env file successfully!")
+        else:
+            print("Error exchanging authorization code for tokens:")
+            print(response.text)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Get Dropbox OAuth tokens.")
+    parser.add_argument("--app-key", required=True, help="Dropbox App Key")
+    parser.add_argument("--app-secret", required=True, help="Dropbox App Secret")
+
+    args = parser.parse_args()
+    get_tokens(args.app_key, args.app_secret)

lyrics_transcriber/{audioshake_transcriber.py → transcribers/audioshake.py}

@@ -2,19 +2,53 @@ import requests
 import time
 import os
 import json
+from .base import BaseTranscriber
 
 
-class AudioShakeTranscriber:
-    def __init__(self, api_token, logger, output_prefix):
-        self.api_token = api_token
+class AudioShakeTranscriber(BaseTranscriber):
+    """Transcription service using AudioShake's API."""
+
+    def __init__(self, api_token=None, logger=None, output_prefix=None):
+        super().__init__(logger)
+        self.api_token = api_token or os.getenv("AUDIOSHAKE_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"""
+        if not self.api_token:
+            raise ValueError("AudioShake API token must be provided either directly or via AUDIOSHAKE_API_TOKEN env var")
+
+    def get_name(self) -> str:
+        return "AudioShake"
+
+    def transcribe(self, audio_filepath: str) -> dict:
+        """
+        Transcribe an audio file using AudioShake API.
+
+        Args:
+            audio_filepath: Path to the audio file to transcribe
+
+        Returns:
+            Dict containing:
+                - segments: List of segments with start/end times and word-level data
+                - text: Full text transcription
+                - metadata: Dict of additional info
+        """
         self.logger.info(f"Starting transcription for {audio_filepath} using AudioShake API")
 
+        # Start job and get results
+        job_id = self.start_transcription(audio_filepath)
+        result = self.get_transcription_result(job_id)
+
+        # Add metadata to the result
+        result["metadata"] = {
+            "service": self.get_name(),
+            "language": "en",  # AudioShake currently only supports English
+        }
+
+        return result
+
+    def start_transcription(self, audio_filepath: str) -> str:
+        """Starts the transcription job and returns the job ID."""
         # Step 1: Upload the audio file
         asset_id = self._upload_file(audio_filepath)
         self.logger.info(f"File uploaded successfully. Asset ID: {asset_id}")
@@ -25,22 +59,17 @@ class AudioShakeTranscriber:
 
         return job_id
 
-    def get_transcription_result(self, job_id):
-        """Gets the results for a previously started job"""
+    def get_transcription_result(self, job_id: str) -> dict:
+        """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
+        # Wait for job completion and get 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
+        # Process and return in standard 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"