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

lyrics_transcriber/output/generator.py

@@ -0,0 +1,271 @@
+from dataclasses import dataclass
+import os
+import logging
+from typing import Dict, Any, List, Optional, Tuple
+import subprocess
+from datetime import timedelta
+
+from lyrics_transcriber.lyrics.base_lyrics_provider import LyricsData
+from .subtitles import create_styled_subtitles, LyricsScreen, LyricsLine, LyricSegment
+from ..correction.corrector import CorrectionResult
+
+
+@dataclass
+class OutputGeneratorConfig:
+    """Configuration for output generation."""
+
+    output_dir: str
+    cache_dir: str
+    video_resolution: str = "360p"
+    video_background_image: Optional[str] = None
+    video_background_color: str = "black"
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if not self.output_dir:
+            raise ValueError("output_dir must be provided")
+        if not self.cache_dir:
+            raise ValueError("cache_dir must be 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}")
+
+
+@dataclass
+class OutputPaths:
+    """Holds paths for generated output files."""
+
+    lrc: Optional[str] = None
+    ass: Optional[str] = None
+    video: Optional[str] = None
+
+
+class OutputGenerator:
+    """Handles generation of various lyrics output formats."""
+
+    def __init__(
+        self,
+        config: OutputGeneratorConfig,
+        logger: Optional[logging.Logger] = None,
+    ):
+        """
+        Initialize OutputGenerator with configuration.
+
+        Args:
+            config: OutputGeneratorConfig instance with required paths
+            logger: Optional logger instance
+        """
+        self.config = config
+        self.logger = logger or logging.getLogger(__name__)
+
+        # Log the configured directories
+        self.logger.debug(f"Initialized OutputGenerator with output_dir: {self.config.output_dir}")
+        self.logger.debug(f"Using cache_dir: {self.config.cache_dir}")
+
+        # Set video resolution parameters
+        self.video_resolution_num, self.font_size, self.line_height = self._get_video_params(self.config.video_resolution)
+
+    def generate_outputs(
+        self,
+        transcription_corrected: CorrectionResult,
+        lyrics_results: List[LyricsData],
+        output_prefix: str,
+        audio_filepath: str,
+        render_video: bool = False,
+    ) -> OutputPaths:
+        """Generate all requested output formats."""
+        outputs = OutputPaths()
+
+        try:
+            # Generate plain lyrics files for each provider
+            for lyrics_data in lyrics_results:
+                provider_name = lyrics_data.metadata.source.title()
+                self.write_plain_lyrics(lyrics_data, f"{output_prefix} (Lyrics {provider_name})")
+
+            if transcription_corrected:
+                # Write corrected lyrics as plain text
+                self.write_plain_lyrics_from_correction(transcription_corrected, f"{output_prefix} (Lyrics Corrected)")
+
+                # Generate LRC
+                outputs.lrc = self.generate_lrc(transcription_corrected, output_prefix)
+
+                # Generate ASS
+                outputs.ass = self.generate_ass(transcription_corrected, output_prefix)
+
+                # Generate video if requested
+                if render_video:
+                    outputs.video = self.generate_video(outputs.ass, audio_filepath, output_prefix)
+
+        except Exception as e:
+            self.logger.error(f"Error generating outputs: {str(e)}")
+            raise
+
+        return outputs
+
+    def _get_output_path(self, output_prefix: str, extension: str) -> str:
+        """Generate full output path for a file."""
+        return os.path.join(self.config.output_dir or self.config.cache_dir, f"{output_prefix}.{extension}")
+
+    def generate_lrc(self, transcription_data: CorrectionResult, output_prefix: str) -> str:
+        """Generate LRC format lyrics file."""
+        self.logger.info("Generating LRC format lyrics")
+        output_path = self._get_output_path(output_prefix, "lrc")
+
+        try:
+            self._write_lrc_file(output_path, transcription_data.segments)
+            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 _write_lrc_file(self, output_path: str, segments: list) -> None:
+        """Write LRC file content."""
+        with open(output_path, "w", encoding="utf-8") as f:
+            for segment in segments:
+                start_time = self._format_lrc_timestamp(segment.start_time)
+                line = f"[{start_time}]{segment.text}\n"
+                f.write(line)
+
+    def generate_ass(self, transcription_data: CorrectionResult, output_prefix: str) -> str:
+        """Generate ASS format subtitles file."""
+        self.logger.info("Generating ASS format subtitles")
+        output_path = self._get_output_path(output_prefix, "ass")
+
+        try:
+            self._write_ass_file(output_path, transcription_data.segments)
+            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 _write_ass_file(self, output_path: str, segments: list) -> None:
+        """Write ASS file content."""
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(self._get_ass_header())
+            for segment in segments:
+                # Change from ts/end_ts to start_time/end_time
+                start_time = self._format_ass_timestamp(segment.start_time)
+                end_time = self._format_ass_timestamp(segment.end_time)
+                line = f"Dialogue: 0,{start_time},{end_time},Default,,0,0,0,,{segment.text}\n"
+                f.write(line)
+
+    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 = self._get_output_path(output_prefix, "mp4")
+
+        try:
+            cmd = self._build_ffmpeg_command(ass_path, audio_path, output_path)
+            self._run_ffmpeg_command(cmd)
+            self.logger.info(f"Video generated: {output_path}")
+            return output_path
+
+        except Exception as e:
+            self.logger.error(f"Failed to generate video: {str(e)}")
+            raise
+
+    def _build_ffmpeg_command(self, ass_path: str, audio_path: str, output_path: str) -> list:
+        """Build FFmpeg command for video generation."""
+        width, height = self.video_resolution_num
+        cmd = ["ffmpeg", "-y"]
+
+        # Input source (background)
+        if self.config.video_background_image:
+            cmd.extend(["-i", self.config.video_background_image])
+        else:
+            cmd.extend(["-f", "lavfi", "-i", f"color=c={self.config.video_background_color}:s={width}x{height}"])
+
+        # Add audio and subtitle inputs
+        cmd.extend(["-i", audio_path, "-vf", f"ass={ass_path}", "-c:v", "libx264", "-c:a", "aac", "-shortest", output_path])
+
+        return cmd
+
+    def _run_ffmpeg_command(self, cmd: list) -> None:
+        """Execute FFmpeg command."""
+        self.logger.debug(f"Running FFmpeg command: {' '.join(cmd)}")
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            self.logger.error(f"FFmpeg error: {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
+"""
+
+    def write_plain_lyrics(self, lyrics_data: LyricsData, output_prefix: str) -> str:
+        """Write plain text lyrics file."""
+        self.logger.info("Writing plain lyrics file")
+        output_path = self._get_output_path(output_prefix, "txt")
+
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(lyrics_data.lyrics)
+            self.logger.info(f"Plain lyrics file generated: {output_path}")
+            return output_path
+
+        except Exception as e:
+            self.logger.error(f"Failed to write plain lyrics file: {str(e)}")
+            raise
+
+    def write_plain_lyrics_from_correction(self, correction_result: CorrectionResult, output_prefix: str) -> str:
+        """Write corrected lyrics as plain text file."""
+        self.logger.info("Writing corrected lyrics file")
+        output_path = self._get_output_path(output_prefix, "txt")
+
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(correction_result.text)
+            self.logger.info(f"Corrected lyrics file generated: {output_path}")
+            return output_path
+
+        except Exception as e:
+            self.logger.error(f"Failed to write corrected lyrics file: {str(e)}")
+            raise

lyrics_transcriber/{utils → output}/subtitles.py

@@ -18,10 +18,10 @@ Functions for generating ASS subtitles from lyric data
 class LyricSegmentIterator:
     def __init__(self, lyrics_segments: List[str]):
         self._segments = lyrics_segments
-        self._current_segment = None
+        self._current_segment = 0
 
     def __iter__(self):
-        self._current_sement = 0
+        self._current_segment = 0
         return self
 
     def __next__(self):
@@ -49,17 +49,17 @@ class LyricSegment:
     def to_ass(self) -> str:
         """Render this segment as part of an ASS event line"""
         duration = (self.end_ts - self.ts).total_seconds() * 100
-        return f"{{\kf{duration}}}{self.text}"
+        return rf"{{\kf{duration}}}{self.text}"
 
     def to_dict(self) -> dict:
-        return {"text": self.text, "ts": str(self.ts), "end_ts": str(self.end_ts) if self.end_ts else None}
+        return {"text": self.text, "ts": self.ts.total_seconds(), "end_ts": self.end_ts.total_seconds() if self.end_ts else None}
 
     @classmethod
     def from_dict(cls, data: dict) -> "LyricSegment":
         return cls(
             text=data["text"],
-            ts=timedelta(seconds=float(data["ts"])),
-            end_ts=timedelta(seconds=float(data["end_ts"])) if data["end_ts"] else None,
+            ts=timedelta(seconds=data["ts"]),
+            end_ts=timedelta(seconds=data["end_ts"]) if data["end_ts"] is not None else None,
         )
 
 
@@ -73,7 +73,7 @@ class LyricsLine:
 
     @property
     def end_ts(self) -> Optional[timedelta]:
-        return self.segments[-1].end_ts
+        return self.segments[-1].end_ts if self.segments else None
 
     @ts.setter
     def ts(self, value):
@@ -105,7 +105,7 @@ class LyricsLine:
         """Decorate line with karaoke tags"""
         # Prefix the tag with centisecs prior to line in screen
         start_time = (self.ts - screen_start_ts).total_seconds() * 100
-        line = f"{{\k{start_time}}}"
+        line = rf"{{\k{start_time}}}"
         prev_end: Optional[timedelta] = None
         for s in self.segments:
             if prev_end is not None and prev_end < s.ts:
@@ -168,10 +168,10 @@ class LyricsScreen:
         events = []
         for i, line in enumerate(self.lines):
             y_position = self.get_line_y(i)
-            
+
             # if self.logger:
             #     self.logger.debug(f"Creating ASS event for line {i + 1} at y-position: {y_position}")
-            
+
             event = line.as_ass_event(self.start_ts, self.end_ts, style, y_position)
             events.append(event)
         return events
@@ -188,12 +188,12 @@ class LyricsScreen:
         return LyricsScreen(new_lines, start_ts)
 
     def to_dict(self) -> dict:
-        return {"lines": [line.to_dict() for line in self.lines], "start_ts": str(self.start_ts) if self.start_ts else None}
+        return {"lines": [line.to_dict() for line in self.lines], "start_ts": self.start_ts.total_seconds() if self.start_ts else None}
 
     @classmethod
     def from_dict(cls, data: dict) -> "LyricsScreen":
         lines = [LyricsLine.from_dict(line_data) for line_data in data["lines"]]
-        start_ts = timedelta(seconds=float(data["start_ts"])) if data["start_ts"] else None
+        start_ts = timedelta(seconds=data["start_ts"]) if data["start_ts"] is not None else None
         return cls(lines=lines, start_ts=start_ts)
 
 

lyrics_transcriber/storage/dropbox.py

@@ -0,0 +1,225 @@
+from dataclasses import dataclass
+from typing import Protocol, BinaryIO, Optional, List, Any
+import os
+import time
+import logging
+import requests
+from dropbox import Dropbox
+from dropbox.files import WriteMode, FileMetadata
+from dropbox.sharing import RequestedVisibility, SharedLinkSettings
+from dropbox.exceptions import AuthError, ApiError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DropboxConfig:
+    """Configuration for Dropbox client."""
+
+    app_key: Optional[str] = None
+    app_secret: Optional[str] = None
+    refresh_token: Optional[str] = None
+
+    @classmethod
+    def from_env(cls) -> "DropboxConfig":
+        """Create config from environment variables."""
+        return cls(
+            app_key=os.environ.get("WHISPER_DROPBOX_APP_KEY"),
+            app_secret=os.environ.get("WHISPER_DROPBOX_APP_SECRET"),
+            refresh_token=os.environ.get("WHISPER_DROPBOX_REFRESH_TOKEN"),
+        )
+
+
+class DropboxAPI(Protocol):
+    """Protocol for Dropbox API operations."""
+
+    def files_upload(self, f: bytes, path: str, mode: WriteMode) -> Any: ...
+    def files_list_folder(self, path: str, recursive: bool = False) -> Any: ...
+    def files_list_folder_continue(self, cursor: str) -> Any: ...
+    def files_download(self, path: str) -> tuple[Any, Any]: ...
+    def files_download_to_file(self, download_path: str, path: str) -> None: ...
+    def files_get_metadata(self, path: str) -> Any: ...
+    def sharing_create_shared_link_with_settings(self, path: str, settings: SharedLinkSettings) -> Any: ...
+    def sharing_list_shared_links(self, path: str) -> Any: ...
+
+
+class DropboxHandler:
+    """Handles Dropbox storage operations with automatic token refresh."""
+
+    def __init__(
+        self,
+        config: Optional[DropboxConfig] = None,
+        client: Optional[DropboxAPI] = None,
+    ):
+        """Initialize the Dropbox handler."""
+        self.config = config or DropboxConfig.from_env()
+        self._validate_config()
+
+        self.client = client or Dropbox(
+            app_key=self.config.app_key,
+            app_secret=self.config.app_secret,
+            oauth2_refresh_token=self.config.refresh_token,
+        )
+
+    def _validate_config(self) -> None:
+        """Validate the configuration."""
+        logger.debug("Validating DropboxConfig with values:")
+        logger.debug(f"app_key: {self.config.app_key[:4] + '...' if self.config.app_key else 'None'}")
+        logger.debug(f"app_secret: {self.config.app_secret[:4] + '...' if self.config.app_secret else 'None'}")
+        logger.debug(f"refresh_token: {self.config.refresh_token[:4] + '...' if self.config.refresh_token else 'None'}")
+
+        missing = []
+        if not self.config.app_key:
+            missing.append("app_key")
+        if not self.config.app_secret:
+            missing.append("app_secret")
+        if not self.config.refresh_token:
+            missing.append("refresh_token")
+
+        if missing:
+            error_msg = f"Missing required Dropbox configuration: {', '.join(missing)}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+    def upload_with_retry(self, file: BinaryIO, path: str, max_retries: int = 3) -> None:
+        """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.client.files_upload(file.read(), path, mode=WriteMode.overwrite)
+                logger.debug(f"Successfully uploaded file to {path}")
+                return
+            except 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}")
+                    raise
+                time.sleep(1 * (attempt + 1))
+
+    def upload_string_with_retry(self, content: str, path: str, max_retries: int = 3) -> None:
+        """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.client.files_upload(content.encode(), path, mode=WriteMode.overwrite)
+                logger.debug(f"Successfully uploaded string content to {path}")
+                return
+            except 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}")
+                    raise
+                time.sleep(1 * (attempt + 1))
+
+    def list_folder_recursive(self, path: str = "") -> List[FileMetadata]:
+        """List all files in a folder recursively."""
+        try:
+            logger.debug(f"Listing files recursively from {path}")
+            entries = []
+            result = self.client.files_list_folder(path, recursive=True)
+
+            while True:
+                entries.extend(result.entries)
+                if not result.has_more:
+                    break
+                result = self.client.files_list_folder_continue(result.cursor)
+
+            return entries
+        except Exception as e:
+            logger.error(f"Error listing files: {str(e)}", exc_info=True)
+            raise
+
+    def download_file_content(self, path: str) -> bytes:
+        """Download and return the content of a file."""
+        try:
+            logger.debug(f"Downloading file content from {path}")
+            return self.client.files_download(path)[1].content
+        except Exception as e:
+            logger.error(f"Error downloading file: {str(e)}", exc_info=True)
+            raise
+
+    def download_folder(self, dropbox_path: str, local_path: str) -> None:
+        """Download all files from a Dropbox folder to a local path."""
+        try:
+            logger.debug(f"Downloading folder {dropbox_path} to {local_path}")
+            entries = self.list_folder_recursive(dropbox_path)
+
+            for entry in entries:
+                if isinstance(entry, FileMetadata):
+                    rel_path = entry.path_display[len(dropbox_path) :].lstrip("/")
+                    local_file_path = os.path.join(local_path, rel_path)
+
+                    os.makedirs(os.path.dirname(local_file_path), exist_ok=True)
+                    logger.debug(f"Downloading {entry.path_display} to {local_file_path}")
+                    self.client.files_download_to_file(local_file_path, entry.path_display)
+
+            logger.debug(f"Successfully downloaded folder {dropbox_path}")
+        except Exception as e:
+            logger.error(f"Error downloading folder: {str(e)}", exc_info=True)
+            raise
+
+    def upload_folder(self, local_path: str, dropbox_path: str) -> None:
+        """Upload all files from a local folder to a Dropbox path."""
+        try:
+            logger.debug(f"Uploading folder {local_path} to {dropbox_path}")
+            for root, _, files in os.walk(local_path):
+                for filename in files:
+                    local_file_path = os.path.join(root, filename)
+                    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.client.files_upload(f.read(), target_path, mode=WriteMode.overwrite)
+
+            logger.debug(f"Successfully uploaded folder {local_path}")
+        except Exception as e:
+            logger.error(f"Error uploading folder: {str(e)}", exc_info=True)
+            raise
+
+    def create_shared_link(self, path: str) -> str:
+        """Create a shared link for a file that's accessible without login."""
+        try:
+            logger.debug(f"Creating shared link for {path}")
+            shared_link = self.client.sharing_create_shared_link_with_settings(
+                path, settings=SharedLinkSettings(requested_visibility=RequestedVisibility.public)
+            )
+            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
+
+    def get_existing_shared_link(self, path: str) -> Optional[str]:
+        """Get existing shared link for a file if it exists."""
+        try:
+            logger.debug(f"Getting existing shared link for {path}")
+            shared_links = self.client.sharing_list_shared_links(path=path).links
+            if shared_links:
+                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
+
+    def create_or_get_shared_link(self, path: str) -> str:
+        """Create a shared link or get existing one."""
+        try:
+            existing_link = self.get_existing_shared_link(path)
+            if existing_link:
+                logger.debug(f"Found existing shared link for {path}")
+                return existing_link
+
+            logger.debug(f"Creating new shared link for {path}")
+            return self.create_shared_link(path)
+        except Exception as e:
+            logger.error(f"Error creating/getting shared link: {str(e)}", exc_info=True)
+            raise
+
+    def file_exists(self, path: str) -> bool:
+        """Check if a file exists in Dropbox."""
+        try:
+            self.client.files_get_metadata(path)
+            return True
+        except:
+            return False