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

lyrics_transcriber/output/generator.py

@@ -1,9 +1,33 @@
+from dataclasses import dataclass
 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
+from typing import List, Optional
+import json
+
+from lyrics_transcriber.types import LyricsData
+from lyrics_transcriber.correction.corrector import CorrectionResult
+from lyrics_transcriber.output.plain_text import PlainTextGenerator
+from lyrics_transcriber.output.lyrics_file import LyricsFileGenerator
+from lyrics_transcriber.output.subtitles import SubtitlesGenerator
+from lyrics_transcriber.output.video import VideoGenerator
+from lyrics_transcriber.output.segment_resizer import SegmentResizer
+from lyrics_transcriber.output.cdg import CDGGenerator
+from lyrics_transcriber.core.config import OutputConfig
+
+
+@dataclass
+class OutputPaths:
+    """Holds paths for generated output files."""
+
+    lrc: Optional[str] = None
+    ass: Optional[str] = None
+    video: Optional[str] = None
+    original_txt: Optional[str] = None
+    corrected_txt: Optional[str] = None
+    corrections_json: Optional[str] = None
+    cdg: Optional[str] = None
+    mp3: Optional[str] = None
+    cdg_zip: Optional[str] = None
 
 
 class OutputGenerator:
@@ -11,158 +35,123 @@ class OutputGenerator:
 
     def __init__(
         self,
+        config: OutputConfig,
         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.
+        Initialize OutputGenerator with configuration.
 
         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
+            config: OutputConfig instance with required paths and settings
+            logger: Optional logger instance
         """
-        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
+        self.config = config
+        self.logger = logger or logging.getLogger(__name__)
 
-        except Exception as e:
-            self.logger.error(f"Failed to generate LRC file: {str(e)}")
-            raise
+        self.logger.debug(f"Initializing OutputGenerator with config: {self.config}")
 
-    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")
+        # Set video resolution parameters
+        self.video_resolution_num, self.font_size, self.line_height = self._get_video_params(self.config.video_resolution)
+
+        self.segment_resizer = SegmentResizer(max_line_length=self.config.max_line_length, logger=self.logger)
+
+        # Initialize generators
+        self.plain_text = PlainTextGenerator(self.config.output_dir, self.logger)
+        self.lyrics_file = LyricsFileGenerator(self.config.output_dir, self.logger)
+
+        if self.config.render_video or self.config.generate_cdg:
+            # Load output styles from JSON
+            try:
+                with open(self.config.output_styles_json, "r") as f:
+                    self.config.styles = json.load(f)
+                self.logger.debug(f"Loaded output styles from: {self.config.output_styles_json}")
+            except Exception as e:
+                raise ValueError(f"Failed to load output styles file: {str(e)}")
+
+        if self.config.generate_cdg:
+            self.cdg = CDGGenerator(self.config.output_dir, self.logger)
+
+        if self.config.render_video:
+            self.subtitle = SubtitlesGenerator(
+                output_dir=self.config.output_dir,
+                video_resolution=self.video_resolution_num,
+                font_size=self.font_size,
+                line_height=self.line_height,
+                styles=self.config.styles,
+                logger=self.logger,
+            )
+
+            self.video = VideoGenerator(
+                output_dir=self.config.output_dir,
+                cache_dir=self.config.cache_dir,
+                video_resolution=self.video_resolution_num,
+                styles=self.config.styles,
+                logger=self.logger,
+            )
+
+        # 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}")
 
-        output_path = os.path.join(self.output_dir or self.cache_dir, f"{output_prefix}.ass")
+    def generate_outputs(
+        self,
+        transcription_corrected: CorrectionResult,
+        lyrics_results: List[LyricsData],
+        output_prefix: str,
+        audio_filepath: str,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> OutputPaths:
+        """Generate all requested output formats."""
+        outputs = OutputPaths()
 
         try:
-            with open(output_path, "w", encoding="utf-8") as f:
-                # Write ASS header
-                f.write(self._get_ass_header())
+            # Generate plain lyrics files for each provider
+            for lyrics_data in lyrics_results:
+                self.plain_text.write_lyrics(lyrics_data, output_prefix)
+
+            # Write original (uncorrected) transcription
+            outputs.original_txt = self.plain_text.write_original_transcription(transcription_corrected, output_prefix)
+
+            # Resize corrected segments to ensure none are longer than max_line_length
+            resized_segments = self.segment_resizer.resize_segments(transcription_corrected.corrected_segments)
+            transcription_corrected.resized_segments = resized_segments
+            outputs.corrections_json = self.write_corrections_data(transcription_corrected, output_prefix)
+
+            # Write corrected lyrics as plain text
+            outputs.corrected_txt = self.plain_text.write_corrected_lyrics(resized_segments, output_prefix)
+
+            # Generate LRC using LyricsFileGenerator
+            outputs.lrc = self.lyrics_file.generate_lrc(resized_segments, output_prefix)
+
+            # Generate CDG file if requested
+            if self.config.generate_cdg:
+                outputs.cdg, outputs.mp3, outputs.cdg_zip = self.cdg.generate_cdg(
+                    segments=resized_segments,
+                    audio_file=audio_filepath,
+                    title=title or output_prefix,
+                    artist=artist or "",
+                    cdg_styles=self.config.styles["cdg"],
+                )
 
-                # 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)
+            # Generate video if requested
+            if self.config.render_video:
+                # Generate ASS subtitles
+                outputs.ass = self.subtitle.generate_ass(resized_segments, output_prefix, audio_filepath)
+                outputs.video = self.video.generate_video(outputs.ass, audio_filepath, output_prefix)
 
-            self.logger.info(f"ASS file generated: {output_path}")
-            return output_path
+            return outputs
 
         except Exception as e:
-            self.logger.error(f"Failed to generate ASS file: {str(e)}")
+            self.logger.error(f"Failed to generate outputs: {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_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 _get_video_params(self, resolution: str) -> tuple:
-        """Get video parameters based on resolution setting."""
+        """Get video parameters: (width, height), font_size, line_height based on video resolution config."""
         match resolution:
             case "4k":
                 return (3840, 2160), 250, 250
@@ -171,40 +160,20 @@ class OutputGenerator:
             case "720p":
                 return (1280, 720), 100, 100
             case "360p":
-                return (640, 360), 50, 50
+                return (640, 360), 40, 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_corrections_data(self, correction_result: CorrectionResult, output_prefix: str) -> str:
+        """Write corrections data to JSON file."""
+        self.logger.info("Writing corrections data JSON")
+        output_path = self._get_output_path(f"{output_prefix} (Lyrics Corrections)", "json")
+
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                json.dump(correction_result.to_dict(), f, indent=2, ensure_ascii=False)
+            self.logger.info(f"Corrections data JSON generated: {output_path}")
+            return output_path
+        except Exception as e:
+            self.logger.error(f"Failed to write corrections data JSON: {str(e)}")
+            raise

lyrics_transcriber/output/lyrics_file.py

@@ -0,0 +1,102 @@
+import logging
+import os
+from typing import List, Optional
+
+from lyrics_transcriber.types import LyricsSegment, Word
+
+
+class LyricsFileGenerator:
+    """Handles generation of lyrics files in various formats (LRC, etc)."""
+
+    def __init__(self, output_dir: str, logger: Optional[logging.Logger] = None):
+        """Initialize LyricsFileGenerator.
+        
+        Args:
+            output_dir: Directory where output files will be written
+            logger: Optional logger instance
+        """
+        self.output_dir = output_dir
+        self.logger = logger or logging.getLogger(__name__)
+
+    def _get_output_path(self, output_prefix: str, extension: str) -> str:
+        """Generate full output path for a file."""
+        return os.path.join(self.output_dir, f"{output_prefix}.{extension}")
+
+    def generate_lrc(self, segments: List[LyricsSegment], output_prefix: str) -> str:
+        """Generate LRC format lyrics file.
+        
+        Args:
+            segments: List of LyricsSegment objects containing word timing data
+            output_prefix: Prefix for output filename
+            
+        Returns:
+            Path to generated LRC file
+        """
+        self.logger.info("Generating LRC format lyrics")
+        output_path = self._get_output_path(f"{output_prefix} (Karaoke)", "lrc")
+
+        try:
+            self._write_lrc_file(output_path, 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[LyricsSegment]) -> None:
+        """Write LRC file content with MidiCo-compatible word-level timestamps.
+
+        Args:
+            output_path: Path to write the LRC file
+            segments: List of LyricsSegment objects containing word timing data
+        """
+        with open(output_path, "w", encoding="utf-8") as f:
+            # Write MidiCo header
+            f.write("[re:MidiCo]\n")
+
+            for segment in segments:
+                for i, word in enumerate(segment.words):
+                    start_time = self._format_lrc_timestamp(word.start_time)
+
+                    # Add space after all words except last in segment
+                    text = word.text
+                    if i != len(segment.words) - 1:
+                        text += " "
+
+                    # Add "/" prefix for first word in segment
+                    prefix = "/" if i == 0 else ""
+
+                    # Write MidiCo formatted line
+                    f.write(f"[{start_time}]1:{prefix}{text}\n")
+
+    def _format_lrc_timestamp(self, seconds: float) -> str:
+        """Format timestamp for MidiCo LRC format (MM:SS.mmm).
+        
+        Args:
+            seconds: Time in seconds
+            
+        Returns:
+            Formatted timestamp string in MM:SS.mmm format
+        """
+        minutes = int(seconds // 60)
+        remaining_seconds = seconds % 60
+        
+        # Convert to milliseconds and round to nearest integer
+        total_milliseconds = round(remaining_seconds * 1000)
+        
+        # Extract seconds and milliseconds
+        seconds_part = total_milliseconds // 1000
+        milliseconds = total_milliseconds % 1000
+        
+        # Handle rollover
+        if seconds_part == 60:
+            seconds_part = 0
+            minutes += 1
+            
+        return f"{minutes:02d}:{seconds_part:02d}.{milliseconds:03d}"
+
+    # Future methods for other lyrics file formats can be added here
+    # def generate_txt(self, segments: List[LyricsSegment], output_prefix: str) -> str:
+    #     """Generate Power Karaoke TXT format lyrics file."""
+    #     pass 

lyrics_transcriber/output/plain_text.py

@@ -0,0 +1,91 @@
+import logging
+import os
+from typing import List, Optional
+
+from lyrics_transcriber.types import LyricsData, LyricsSegment
+from lyrics_transcriber.correction.corrector import CorrectionResult
+
+class PlainTextGenerator:
+    """Handles generation of plain text output files for lyrics and transcriptions."""
+
+    def __init__(self, output_dir: str, logger: Optional[logging.Logger] = None):
+        """Initialize PlainTextGenerator.
+        
+        Args:
+            output_dir: Directory where output files will be written
+            logger: Optional logger instance
+        """
+        self.output_dir = output_dir
+        self.logger = logger or logging.getLogger(__name__)
+
+    def _get_output_path(self, output_prefix: str, extension: str) -> str:
+        """Generate full output path for a file."""
+        return os.path.join(self.output_dir, f"{output_prefix}.{extension}")
+
+    def write_lyrics(self, lyrics_data: LyricsData, output_prefix: str) -> str:
+        """Write plain text lyrics file from provider data.
+        
+        Args:
+            lyrics_data: LyricsData from a lyrics provider
+            output_prefix: Prefix for output filename
+            
+        Returns:
+            Path to generated file
+        """
+        self.logger.info("Writing plain lyrics file")
+        provider_name = lyrics_data.metadata.source.title()
+        output_path = self._get_output_path(f"{output_prefix} (Lyrics {provider_name})", "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_corrected_lyrics(self, segments: List[LyricsSegment], output_prefix: str) -> str:
+        """Write corrected lyrics as plain text file.
+        
+        Args:
+            segments: List of corrected LyricsSegment objects
+            output_prefix: Prefix for output filename
+            
+        Returns:
+            Path to generated file
+        """
+        self.logger.info("Writing corrected lyrics file")
+        output_path = self._get_output_path(f"{output_prefix} (Lyrics Corrected)", "txt")
+
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                for segment in segments:
+                    f.write(f"{segment.text}\n")
+            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
+
+    def write_original_transcription(self, correction_result: CorrectionResult, output_prefix: str) -> str:
+        """Write original (uncorrected) transcription as plain text.
+        
+        Args:
+            correction_result: CorrectionResult containing original transcription
+            output_prefix: Prefix for output filename
+            
+        Returns:
+            Path to generated file
+        """
+        self.logger.info("Writing original transcription file")
+        output_path = self._get_output_path(f"{output_prefix} (Lyrics Uncorrected)", "txt")
+
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(correction_result.transcribed_text)
+            self.logger.info(f"Original transcription file generated: {output_path}")
+            return output_path
+        except Exception as e:
+            self.logger.error(f"Failed to write original transcription file: {str(e)}")
+            raise