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

lyrics_transcriber/output/generator.py

@@ -1,33 +1,18 @@
 from dataclasses import dataclass
 import os
 import logging
-from typing import Dict, Any, List, Optional, Tuple
-import subprocess
-from datetime import timedelta
+from typing import List, Optional
+import json
 
-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}")
+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
@@ -37,6 +22,12 @@ class OutputPaths:
     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:
@@ -44,33 +35,72 @@ class OutputGenerator:
 
     def __init__(
         self,
-        config: OutputGeneratorConfig,
+        config: OutputConfig,
         logger: Optional[logging.Logger] = None,
     ):
         """
         Initialize OutputGenerator with configuration.
 
         Args:
-            config: OutputGeneratorConfig instance with required paths
+            config: OutputConfig instance with required paths and settings
             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}")
+        self.logger.debug(f"Initializing OutputGenerator with config: {self.config}")
 
         # 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}")
+
     def generate_outputs(
         self,
         transcription_corrected: CorrectionResult,
         lyrics_results: List[LyricsData],
         output_prefix: str,
         audio_filepath: str,
-        render_video: bool = False,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
     ) -> OutputPaths:
         """Generate all requested output formats."""
         outputs = OutputPaths()
@@ -78,122 +108,50 @@ class OutputGenerator:
         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})")
+                self.plain_text.write_lyrics(lyrics_data, output_prefix)
 
-            if transcription_corrected:
-                # Write corrected lyrics as plain text
-                self.write_plain_lyrics_from_correction(transcription_corrected, f"{output_prefix} (Lyrics Corrected)")
+            # Write original (uncorrected) transcription
+            outputs.original_txt = self.plain_text.write_original_transcription(transcription_corrected, output_prefix)
 
-                # Generate LRC
-                outputs.lrc = self.generate_lrc(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)
 
-                # Generate ASS
-                outputs.ass = self.generate_ass(transcription_corrected, output_prefix)
+            # Write corrected lyrics as plain text
+            outputs.corrected_txt = self.plain_text.write_corrected_lyrics(resized_segments, output_prefix)
 
-                # Generate video if requested
-                if render_video:
-                    outputs.video = self.generate_video(outputs.ass, audio_filepath, output_prefix)
+            # Generate LRC using LyricsFileGenerator
+            outputs.lrc = self.lyrics_file.generate_lrc(resized_segments, output_prefix)
 
-        except Exception as e:
-            self.logger.error(f"Error generating outputs: {str(e)}")
-            raise
+            # 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"],
+                )
 
-        return outputs
+            # 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)
 
-    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
+            return outputs
 
         except Exception as e:
-            self.logger.error(f"Failed to generate LRC file: {str(e)}")
+            self.logger.error(f"Failed to generate outputs: {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_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
@@ -202,70 +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_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")
+    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:
-                f.write(lyrics_data.lyrics)
-            self.logger.info(f"Plain lyrics file generated: {output_path}")
+                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 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)}")
+            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