karaoke-gen 0.75.53__py3-none-any.whl → 0.81.1__py3-none-any.whl

karaoke_gen/karaoke_gen.py

@@ -31,6 +31,12 @@ from .video_generator import VideoGenerator
 from .video_background_processor import VideoBackgroundProcessor
 from .audio_fetcher import create_audio_fetcher, AudioFetcherError, NoResultsError, UserCancelledError
 
+# Import lyrics_transcriber components for post-review countdown and video rendering
+from lyrics_transcriber.output.countdown_processor import CountdownProcessor
+from lyrics_transcriber.output.generator import OutputGenerator
+from lyrics_transcriber.types import CorrectionResult
+from lyrics_transcriber.core.config import OutputConfig as LyricsOutputConfig
+
 
 class KaraokePrep:
     def __init__(
@@ -482,41 +488,56 @@ class KaraokePrep:
                     self.logger.info(f"Found existing media files matching extractor '{self.extractor}', skipping download/conversion.")
 
                 elif getattr(self, '_use_audio_fetcher', False):
-                    # Use flacfetch to search and download audio
-                    self.logger.info(f"Using flacfetch to search and download: {self.artist} - {self.title}")
-                    
                     try:
-                        # Search and download audio using the AudioFetcher
-                        fetch_result = self.audio_fetcher.search_and_download(
-                            artist=self.artist,
-                            title=self.title,
-                            output_dir=track_output_dir,
-                            output_filename=f"{artist_title} (flacfetch)",
-                            auto_select=self.auto_download,
-                        )
-                        
-                        # Update extractor to reflect the actual provider used
-                        self.extractor = f"flacfetch-{fetch_result.provider}"
-                        
+                        # Check if this is a URL download or search+download
+                        if getattr(self, '_use_url_download', False):
+                            # Direct URL download (e.g., YouTube URL)
+                            self.logger.info(f"Using flacfetch to download from URL: {self.url}")
+
+                            fetch_result = self.audio_fetcher.download_from_url(
+                                url=self.url,
+                                output_dir=track_output_dir,
+                                output_filename=f"{artist_title} (youtube)" if artist_title != "Unknown - Unknown" else None,
+                                artist=self.artist,
+                                title=self.title,
+                            )
+
+                            # Update extractor to reflect the source
+                            self.extractor = "youtube"
+                        else:
+                            # Use flacfetch to search and download audio
+                            self.logger.info(f"Using flacfetch to search and download: {self.artist} - {self.title}")
+
+                            fetch_result = self.audio_fetcher.search_and_download(
+                                artist=self.artist,
+                                title=self.title,
+                                output_dir=track_output_dir,
+                                output_filename=f"{artist_title} (flacfetch)",
+                                auto_select=self.auto_download,
+                            )
+
+                            # Update extractor to reflect the actual provider used
+                            self.extractor = f"flacfetch-{fetch_result.provider}"
+
                         # Set up the output paths
                         output_filename_no_extension = os.path.join(track_output_dir, f"{artist_title} ({self.extractor})")
-                        
+
                         # Copy/move the downloaded file to the expected location
                         processed_track["input_media"] = self.file_handler.download_audio_from_fetcher_result(
                             fetch_result.filepath, output_filename_no_extension
                         )
-                        
+
                         self.logger.info(f"Audio downloaded from {fetch_result.provider}: {processed_track['input_media']}")
-                        
+
                         # Convert to WAV for audio processing
                         self.logger.info("Converting downloaded audio to WAV for processing...")
                         processed_track["input_audio_wav"] = self.file_handler.convert_to_wav(
                             processed_track["input_media"], output_filename_no_extension
                         )
-                        
+
                         # No still image for audio-only downloads
                         processed_track["input_still_image"] = None
-                        
+
                     except UserCancelledError:
                         # User cancelled - propagate up to CLI for graceful exit
                         raise
@@ -692,6 +713,113 @@ class KaraokePrep:
 
                 self.logger.info("=== Parallel Processing Complete ===")
 
+            # === POST-TRANSCRIPTION: Add countdown and render video ===
+            # Since lyrics_processor.py now always defers countdown and video rendering,
+            # we handle it here after human review is complete. This ensures the review UI
+            # shows accurate, unshifted timestamps (same behavior as cloud backend).
+            if processed_track.get("lyrics") and self.render_video:
+                self.logger.info("=== Processing Countdown and Video Rendering ===")
+
+                from .utils import sanitize_filename
+                sanitized_artist = sanitize_filename(self.artist)
+                sanitized_title = sanitize_filename(self.title)
+                lyrics_dir = os.path.join(track_output_dir, "lyrics")
+
+                # Find the corrections JSON file
+                corrections_filename = f"{sanitized_artist} - {sanitized_title} (Lyrics Corrections).json"
+                corrections_filepath = os.path.join(lyrics_dir, corrections_filename)
+
+                if os.path.exists(corrections_filepath):
+                    self.logger.info(f"Loading corrections from: {corrections_filepath}")
+
+                    with open(corrections_filepath, 'r', encoding='utf-8') as f:
+                        corrections_data = json.load(f)
+
+                    # Convert to CorrectionResult
+                    correction_result = CorrectionResult.from_dict(corrections_data)
+                    self.logger.info(f"Loaded CorrectionResult with {len(correction_result.corrected_segments)} segments")
+
+                    # Get the audio file path
+                    audio_path = processed_track["input_audio_wav"]
+
+                    # Add countdown intro if needed (songs that start within 3 seconds)
+                    self.logger.info("Processing countdown intro (if needed)...")
+                    cache_dir = os.path.join(track_output_dir, "cache")
+                    os.makedirs(cache_dir, exist_ok=True)
+
+                    countdown_processor = CountdownProcessor(
+                        cache_dir=cache_dir,
+                        logger=self.logger,
+                    )
+
+                    correction_result, audio_path, padding_added, padding_seconds = countdown_processor.process(
+                        correction_result=correction_result,
+                        audio_filepath=audio_path,
+                    )
+
+                    # Update processed_track with countdown info
+                    processed_track["countdown_padding_added"] = padding_added
+                    processed_track["countdown_padding_seconds"] = padding_seconds
+                    if padding_added:
+                        processed_track["padded_vocals_audio"] = audio_path
+                        self.logger.info(
+                            f"=== COUNTDOWN PADDING ADDED ===\n"
+                            f"Added {padding_seconds}s padding to audio and shifted timestamps.\n"
+                            f"Instrumental tracks will be padded after separation to maintain sync."
+                        )
+                    else:
+                        self.logger.info("No countdown needed - song starts after 3 seconds")
+
+                    # Save the updated corrections with countdown timestamps
+                    updated_corrections_data = correction_result.to_dict()
+                    with open(corrections_filepath, 'w', encoding='utf-8') as f:
+                        json.dump(updated_corrections_data, f, indent=2)
+                    self.logger.info(f"Saved countdown-adjusted corrections to: {corrections_filepath}")
+
+                    # Render video with lyrics
+                    self.logger.info("Rendering karaoke video with synchronized lyrics...")
+
+                    output_config = LyricsOutputConfig(
+                        output_dir=lyrics_dir,
+                        cache_dir=cache_dir,
+                        output_styles_json=self.style_params_json,
+                        render_video=True,
+                        generate_cdg=False,
+                        generate_plain_text=True,
+                        generate_lrc=True,
+                        video_resolution="4k",
+                        subtitle_offset_ms=self.subtitle_offset_ms,
+                    )
+
+                    output_generator = OutputGenerator(output_config, self.logger)
+                    output_prefix = f"{sanitized_artist} - {sanitized_title}"
+
+                    outputs = output_generator.generate_outputs(
+                        transcription_corrected=correction_result,
+                        lyrics_results={},  # Lyrics already written during transcription phase
+                        audio_filepath=audio_path,
+                        output_prefix=output_prefix,
+                    )
+
+                    # Copy video to expected location in parent directory
+                    if outputs and outputs.video:
+                        source_video = outputs.video
+                        dest_video = os.path.join(track_output_dir, f"{artist_title} (With Vocals).mkv")
+                        shutil.copy2(source_video, dest_video)
+                        self.logger.info(f"Video rendered successfully: {dest_video}")
+                        processed_track["with_vocals_video"] = dest_video
+
+                        # Update ASS filepath for video background processing
+                        if outputs.ass:
+                            processed_track["ass_filepath"] = outputs.ass
+                    else:
+                        self.logger.warning("Video rendering did not produce expected output")
+                else:
+                    self.logger.warning(f"Corrections file not found: {corrections_filepath}")
+                    self.logger.warning("Skipping countdown processing and video rendering")
+            elif not self.render_video:
+                self.logger.info("Video rendering disabled - skipping countdown and video generation")
+
             # Apply video background if requested and lyrics were processed
             if self.video_background_processor and processed_track.get("lyrics"):
                 self.logger.info("=== Processing Video Background ===")
@@ -991,17 +1119,56 @@ class KaraokePrep:
 
         return tracks
 
+    def _is_url(self, string: str) -> bool:
+        """Check if a string is a URL."""
+        return string is not None and (string.startswith("http://") or string.startswith("https://"))
+
     async def process(self):
         if self.input_media is not None and os.path.isdir(self.input_media):
             self.logger.info(f"Input media {self.input_media} is a local folder, processing each file individually...")
             return await self.process_folder()
         elif self.input_media is not None and os.path.isfile(self.input_media):
             self.logger.info(f"Input media {self.input_media} is a local file, audio download will be skipped")
+            return [await self.prep_single_track()]
+        elif self.input_media is not None and self._is_url(self.input_media):
+            # URL provided - download directly via flacfetch
+            self.logger.info(f"Input media {self.input_media} is a URL, downloading via flacfetch...")
+
+            # Extract video ID for metadata if it's a YouTube URL
+            video_id = None
+            youtube_patterns = [
+                r'(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]{11})',
+                r'youtube\.com/embed/([a-zA-Z0-9_-]{11})',
+                r'youtube\.com/v/([a-zA-Z0-9_-]{11})',
+            ]
+            for pattern in youtube_patterns:
+                match = re.search(pattern, self.input_media)
+                if match:
+                    video_id = match.group(1)
+                    break
+
+            # Set up the extracted_info for metadata consistency
+            self.extracted_info = {
+                "title": f"{self.artist} - {self.title}" if self.artist and self.title else video_id or "Unknown",
+                "artist": self.artist or "",
+                "track_title": self.title or "",
+                "extractor_key": "youtube",
+                "id": video_id or self.input_media,
+                "url": self.input_media,
+                "source": "youtube",
+            }
+            self.extractor = "youtube"
+            self.url = self.input_media
+
+            # Mark that we need to use audio fetcher for URL download
+            self._use_audio_fetcher = True
+            self._use_url_download = True  # New flag for URL-based download
+
             return [await self.prep_single_track()]
         elif self.artist and self.title:
             # No input file provided - use flacfetch to search and download audio
             self.logger.info(f"No input file provided, using flacfetch to search for: {self.artist} - {self.title}")
-            
+
             # Set up the extracted_info for metadata consistency
             self.extracted_info = {
                 "title": f"{self.artist} - {self.title}",
@@ -1014,13 +1181,12 @@ class KaraokePrep:
             }
             self.extractor = "flacfetch"
             self.url = None  # URL will be determined by flacfetch
-            
+
             # Mark that we need to use audio fetcher for download
             self._use_audio_fetcher = True
-            
+
             return [await self.prep_single_track()]
         else:
             raise ValueError(
-                "Either a local file path or both artist and title must be provided. "
-                "URL-based input has been replaced with flacfetch audio fetching."
+                "Either a local file path, a URL, or both artist and title must be provided."
             )

karaoke_gen/lyrics_processor.py

@@ -170,15 +170,15 @@ class LyricsProcessor:
     def _check_transcription_providers(self) -> dict:
         """
         Check which transcription providers are configured and return their status.
-        
+
         Returns:
             dict with 'configured' (list of provider names) and 'missing' (list of missing configs)
         """
         load_dotenv()
-        
+
         configured = []
         missing = []
-        
+
         # Check AudioShake
         audioshake_token = os.getenv("AUDIOSHAKE_API_TOKEN")
         if audioshake_token:
@@ -187,7 +187,7 @@ class LyricsProcessor:
         else:
             missing.append("AudioShake (AUDIOSHAKE_API_TOKEN)")
             self.logger.debug("AudioShake transcription provider: not configured (missing AUDIOSHAKE_API_TOKEN)")
-        
+
         # Check Whisper via RunPod
         runpod_key = os.getenv("RUNPOD_API_KEY")
         whisper_id = os.getenv("WHISPER_RUNPOD_ID")
@@ -203,7 +203,16 @@ class LyricsProcessor:
         else:
             missing.append("Whisper (RUNPOD_API_KEY + WHISPER_RUNPOD_ID)")
             self.logger.debug("Whisper transcription provider: not configured")
-        
+
+        # Check Local Whisper (whisper-timestamped)
+        try:
+            import whisper_timestamped
+            configured.append("Local Whisper")
+            self.logger.debug("Local Whisper transcription provider: configured (whisper-timestamped installed)")
+        except ImportError:
+            missing.append("Local Whisper (pip install karaoke-gen[local-whisper])")
+            self.logger.debug("Local Whisper transcription provider: not configured (whisper-timestamped not installed)")
+
         return {"configured": configured, "missing": missing}
 
     def _build_transcription_provider_error_message(self, missing_providers: list) -> str:
@@ -221,12 +230,18 @@ class LyricsProcessor:
             "   - Set environment variable: AUDIOSHAKE_API_TOKEN=your_token\n"
             "   - Get an API key at: https://www.audioshake.ai/\n"
             "\n"
-            "2. Whisper via RunPod (Open-source alternative)\n"
+            "2. Whisper via RunPod (Cloud-based open-source)\n"
             "   - Set environment variables:\n"
             "     RUNPOD_API_KEY=your_key\n"
             "     WHISPER_RUNPOD_ID=your_endpoint_id\n"
             "   - Set up a Whisper endpoint at: https://www.runpod.io/\n"
             "\n"
+            "3. Local Whisper (No cloud required - runs on your machine)\n"
+            "   - Install with: pip install karaoke-gen[local-whisper]\n"
+            "   - For CPU-only: pip install torch torchaudio --index-url https://download.pytorch.org/whl/cpu\n"
+            "                   pip install karaoke-gen[local-whisper]\n"
+            "   - Requires 2-10GB RAM depending on model size\n"
+            "\n"
             "ALTERNATIVES:\n"
             "\n"
             "- Use --skip-lyrics flag to generate instrumental-only karaoke (no synchronized lyrics)\n"
@@ -348,6 +363,10 @@ class LyricsProcessor:
         # Create config objects for LyricsTranscriber
         transcriber_config = TranscriberConfig(
             audioshake_api_token=env_config.get("audioshake_api_token"),
+            runpod_api_key=env_config.get("runpod_api_key"),
+            whisper_runpod_id=env_config.get("whisper_runpod_id"),
+            # Local Whisper is enabled by default as a fallback when no cloud providers are configured
+            enable_local_whisper=True,
         )
 
         lyrics_config = LyricsConfig(
@@ -364,41 +383,30 @@ class LyricsProcessor:
         self.logger.info(f"  rapidapi_key: {env_config.get('rapidapi_key')[:3] + '...' if env_config.get('rapidapi_key') else 'None'}")
         self.logger.info(f"  lyrics_file: {self.lyrics_file}")
 
-        # Detect if we're running in a serverless environment (Modal)
-        # Modal sets specific environment variables we can check for
-        is_serverless = (
-            os.getenv("MODAL_TASK_ID") is not None or 
-            os.getenv("MODAL_FUNCTION_NAME") is not None or
-            os.path.exists("/.modal")  # Modal creates this directory in containers
-        )
-        
-        # In serverless environment, disable interactive review even if skip_transcription_review=False
-        # This preserves CLI behavior while fixing serverless hanging
-        enable_review_setting = not self.skip_transcription_review and not is_serverless
-        
-        if is_serverless and not self.skip_transcription_review:
-            self.logger.info("Detected serverless environment - disabling interactive review to prevent hanging")
-        
-        # In serverless environment, disable video generation during Phase 1 to save compute
-        # Video will be generated in Phase 2 after human review
-        serverless_render_video = render_video and not is_serverless
-        
-        if is_serverless and render_video:
-            self.logger.info("Detected serverless environment - deferring video generation until after review")
-        
+        # Always defer countdown and video rendering to a later phase.
+        # This ensures the review UI (both local and cloud) shows original timing
+        # without the 3-second countdown shift. The caller is responsible for:
+        # - Local CLI: karaoke_gen.py adds countdown and renders video after transcription
+        # - Cloud backend: render_video_worker.py adds countdown and renders video
+        #
+        # This design ensures consistent behavior regardless of environment,
+        # and the review UI always shows accurate, unshifted timestamps.
+        self.logger.info("Deferring countdown and video rendering to post-review phase")
+
         output_config = OutputConfig(
             output_styles_json=self.style_params_json,
             output_dir=lyrics_dir,
-            render_video=serverless_render_video,  # Disable video in serverless Phase 1
+            render_video=False,  # Always defer - caller handles video rendering after countdown
             fetch_lyrics=True,
             run_transcription=not self.skip_transcription,
             run_correction=True,
             generate_plain_text=True,
             generate_lrc=True,
-            generate_cdg=False,  # Also defer CDG generation to Phase 2 
+            generate_cdg=False,  # CDG generation disabled (not currently supported)
             video_resolution="4k",
-            enable_review=enable_review_setting,
+            enable_review=not self.skip_transcription_review,  # Honor the caller's setting
             subtitle_offset_ms=self.subtitle_offset_ms,
+            add_countdown=False,  # Always defer - caller handles countdown after review
         )
 
         # Add this log entry to debug the OutputConfig

karaoke_gen/utils/__init__.py

@@ -1,9 +1,35 @@
 import re
 
+# Unicode character replacements for ASCII-safe filenames
+# These characters cause issues with HTTP headers (latin-1 encoding) and some filesystems
+UNICODE_REPLACEMENTS = {
+    # Curly/smart quotes -> straight quotes
+    "\u2018": "'",  # LEFT SINGLE QUOTATION MARK
+    "\u2019": "'",  # RIGHT SINGLE QUOTATION MARK (the one causing the bug)
+    "\u201A": "'",  # SINGLE LOW-9 QUOTATION MARK
+    "\u201B": "'",  # SINGLE HIGH-REVERSED-9 QUOTATION MARK
+    "\u201C": '"',  # LEFT DOUBLE QUOTATION MARK
+    "\u201D": '"',  # RIGHT DOUBLE QUOTATION MARK
+    "\u201E": '"',  # DOUBLE LOW-9 QUOTATION MARK
+    "\u201F": '"',  # DOUBLE HIGH-REVERSED-9 QUOTATION MARK
+    # Other common problematic characters
+    "\u2013": "-",  # EN DASH
+    "\u2014": "-",  # EM DASH
+    "\u2026": "...",  # HORIZONTAL ELLIPSIS
+    "\u00A0": " ",  # NON-BREAKING SPACE
+}
+
+
 def sanitize_filename(filename):
     """Replace or remove characters that are unsafe for filenames."""
     if filename is None:
         return None
+
+    # First, normalize Unicode characters that cause HTTP header encoding issues
+    # (e.g., curly quotes from macOS/Word that can't be encoded in latin-1)
+    for unicode_char, ascii_replacement in UNICODE_REPLACEMENTS.items():
+        filename = filename.replace(unicode_char, ascii_replacement)
+
     # Replace problematic characters with underscores
     for char in ["\\", "/", ":", "*", "?", '"', "<", ">", "|"]:
         filename = filename.replace(char, "_")

karaoke_gen/utils/cli_args.py

@@ -242,9 +242,17 @@ def create_parser(prog: str = "karaoke-gen") -> argparse.ArgumentParser:
 
     # Style Configuration
     style_group = parser.add_argument_group("Style Configuration")
+    style_group.add_argument(
+        "--theme",
+        help="Optional: Theme ID for pre-made styles stored in GCS (e.g., 'nomad', 'default'). "
+             "When using a theme, CDG/TXT are enabled by default. "
+             "Example: --theme=nomad",
+    )
     style_group.add_argument(
         "--style_params_json",
-        help="Optional: Path to JSON file containing style configuration. Example: --style_params_json='/path/to/style_params.json'",
+        help="Optional: Path to JSON file containing style configuration. "
+             "Takes precedence over --theme if both are provided. "
+             "Example: --style_params_json='/path/to/style_params.json'",
     )
     style_group.add_argument(
         "--style_override",

karaoke_gen/utils/gen_cli.py

@@ -320,7 +320,7 @@ async def async_main():
         # Check if user provided a custom value (not the default hosted URL)
         default_hosted_urls = [
             'https://gen.nomadkaraoke.com/lyrics',
-            'https://lyrics.nomadkaraoke.com'
+            'https://gen.nomadkaraoke.com/lyrics/'
         ]
         if args.review_ui_url.rstrip('/') not in [url.rstrip('/') for url in default_hosted_urls]:
             # User explicitly wants a specific URL (e.g., Vite dev server)

karaoke_gen/utils/remote_cli.py

@@ -292,6 +292,8 @@ class RemoteKaraokeClient:
         # Two-phase workflow (Batch 6)
         prep_only: bool = False,
         keep_brand_code: Optional[str] = None,
+        # Theme system
+        theme_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Submit a new karaoke generation job from a YouTube/online URL.
@@ -322,6 +324,7 @@ class RemoteKaraokeClient:
             clean_instrumental_model: Model for clean instrumental separation
             backing_vocals_models: List of models for backing vocals separation
             other_stems_models: List of models for other stems (bass, drums, etc.)
+            theme_id: Theme ID from GCS themes (e.g., 'nomad', 'default')
         """
         self.logger.info(f"Submitting URL-based job: {url}")
         
@@ -367,7 +370,10 @@ class RemoteKaraokeClient:
             create_request['prep_only'] = prep_only
         if keep_brand_code:
             create_request['keep_brand_code'] = keep_brand_code
-        
+        # Theme system
+        if theme_id:
+            create_request['theme_id'] = theme_id
+
         self.logger.info(f"Creating URL-based job at {self.config.service_url}/api/jobs/create-from-url")
         
         response = self._request('POST', '/api/jobs/create-from-url', json=create_request)
@@ -396,9 +402,9 @@ class RemoteKaraokeClient:
         return result
     
     def submit_job(
-        self, 
-        filepath: str, 
-        artist: str, 
+        self,
+        filepath: str,
+        artist: str,
         title: str,
         style_params_path: Optional[str] = None,
         enable_cdg: bool = True,
@@ -425,6 +431,8 @@ class RemoteKaraokeClient:
         # Two-phase workflow (Batch 6)
         prep_only: bool = False,
         keep_brand_code: Optional[str] = None,
+        # Theme system
+        theme_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Submit a new karaoke generation job with optional style configuration.
@@ -456,6 +464,7 @@ class RemoteKaraokeClient:
             backing_vocals_models: List of models for backing vocals separation
             other_stems_models: List of models for other stems (bass, drums, etc.)
             existing_instrumental: Path to existing instrumental file to use instead of AI separation
+            theme_id: Theme ID from GCS themes (e.g., 'nomad', 'default')
         """
         file_path = Path(filepath)
         
@@ -574,7 +583,10 @@ class RemoteKaraokeClient:
             create_request['prep_only'] = prep_only
         if keep_brand_code:
             create_request['keep_brand_code'] = keep_brand_code
-        
+        # Theme system
+        if theme_id:
+            create_request['theme_id'] = theme_id
+
         response = self._request('POST', '/api/jobs/create-with-upload-urls', json=create_request)
         
         if response.status_code != 200:
@@ -1195,6 +1207,8 @@ class RemoteKaraokeClient:
         clean_instrumental_model: Optional[str] = None,
         backing_vocals_models: Optional[list] = None,
         other_stems_models: Optional[list] = None,
+        # Theme system
+        theme_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Search for audio by artist and title (Batch 5 - Flacfetch integration).
@@ -1247,7 +1261,10 @@ class RemoteKaraokeClient:
             request_data['backing_vocals_models'] = backing_vocals_models
         if other_stems_models:
             request_data['other_stems_models'] = other_stems_models
-        
+        # Theme system
+        if theme_id:
+            request_data['theme_id'] = theme_id
+
         # Prepare style files for upload if provided
         style_files = []
         local_style_files: Dict[str, str] = {}  # file_type -> local_path
@@ -3029,6 +3046,8 @@ def main():
         logger.info(f"Searching for: {artist} - {title}")
         if getattr(args, 'auto_download', False) or config.non_interactive:
             logger.info(f"Auto-download: enabled (will auto-select best source)")
+        if getattr(args, 'theme', None):
+            logger.info(f"Theme: {args.theme}")
         if args.style_params_json:
             logger.info(f"Style: {args.style_params_json}")
         logger.info(f"CDG: {args.enable_cdg}, TXT: {args.enable_txt}")
@@ -3070,6 +3089,8 @@ def main():
                 clean_instrumental_model=getattr(args, 'clean_instrumental_model', None),
                 backing_vocals_models=getattr(args, 'backing_vocals_models', None),
                 other_stems_models=getattr(args, 'other_stems_models', None),
+                # Theme system
+                theme_id=getattr(args, 'theme', None),
             )
             
             job_id = result.get('job_id')
@@ -3106,6 +3127,8 @@ def main():
         logger.info(f"Title: {title}")
     if not artist and not title and is_url_input:
         logger.info(f"Artist/Title: (will be auto-detected from URL)")
+    if getattr(args, 'theme', None):
+        logger.info(f"Theme: {args.theme}")
     if args.style_params_json:
         logger.info(f"Style: {args.style_params_json}")
     logger.info(f"CDG: {args.enable_cdg}, TXT: {args.enable_txt}")
@@ -3206,6 +3229,8 @@ def main():
                 # Two-phase workflow (Batch 6)
                 prep_only=getattr(args, 'prep_only', False),
                 keep_brand_code=keep_brand_code_value,
+                # Theme system
+                theme_id=getattr(args, 'theme', None),
             )
         else:
             # File-based job submission
@@ -3238,6 +3263,8 @@ def main():
                 # Two-phase workflow (Batch 6)
                 prep_only=getattr(args, 'prep_only', False),
                 keep_brand_code=keep_brand_code_value,
+                # Theme system
+                theme_id=getattr(args, 'theme', None),
             )
         job_id = result.get('job_id')
         style_assets = result.get('style_assets_uploaded', [])