karaoke-gen 0.71.17__tar.gz → 0.71.29__tar.gz

{karaoke_gen-0.71.17 → karaoke_gen-0.71.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karaoke-gen
-Version: 0.71.17
+Version: 0.71.29
 Summary: Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens.
 License: MIT
 License-File: LICENSE

{karaoke_gen-0.71.17 → karaoke_gen-0.71.29}/karaoke_gen/karaoke_finalise/karaoke_finalise.py

@@ -860,7 +860,7 @@ class KaraokeFinalise:
         return env_mov_input, ffmpeg_filter
 
     def remux_and_encode_output_video_files(self, with_vocals_file, input_files, output_files):
-        self.logger.info(f"Remuxing and encoding output video files...")
+        self.logger.info(f"Remuxing and encoding output video files (4 formats, ~15-20 minutes total)...")
 
         # Check if output files already exist
         if os.path.isfile(output_files["final_karaoke_lossless_mp4"]) and os.path.isfile(output_files["final_karaoke_lossless_mkv"]):
@@ -871,16 +871,20 @@ class KaraokeFinalise:
                 return
 
         # Create karaoke version with instrumental audio
+        self.logger.info(f"[Step 1/6] Remuxing video with instrumental audio...")
         self.remux_with_instrumental(with_vocals_file, input_files["instrumental_audio"], output_files["karaoke_mp4"])
 
         # Convert the with vocals video to MP4 if needed
         if not with_vocals_file.endswith(".mp4"):
+            self.logger.info(f"[Step 2/6] Converting karaoke video to MP4...")
             self.convert_mov_to_mp4(with_vocals_file, output_files["with_vocals_mp4"])
 
             # Delete the with vocals mov after successfully converting it to mp4
             if not self.dry_run and os.path.isfile(with_vocals_file):
                 self.logger.info(f"Deleting with vocals MOV file: {with_vocals_file}")
                 os.remove(with_vocals_file)
+        else:
+            self.logger.info(f"[Step 2/6] Skipped - video already in MP4 format")
 
         # Quote file paths to handle special characters
         title_mov_file = shlex.quote(os.path.abspath(input_files["title_mov"]))
@@ -889,10 +893,17 @@ class KaraokeFinalise:
         # Prepare concat filter for combining videos
         env_mov_input, ffmpeg_filter = self.prepare_concat_filter(input_files)
 
-        # Create all output versions
+        # Create all output versions with progress logging
+        self.logger.info(f"[Step 3/6] Encoding lossless 4K MP4 (title + karaoke + end, ~5 minutes)...")
         self.encode_lossless_mp4(title_mov_file, karaoke_mp4_file, env_mov_input, ffmpeg_filter, output_files["final_karaoke_lossless_mp4"])
+        
+        self.logger.info(f"[Step 4/6] Encoding lossy 4K MP4 with AAC audio (~1 minute)...")
         self.encode_lossy_mp4(output_files["final_karaoke_lossless_mp4"], output_files["final_karaoke_lossy_mp4"])
+        
+        self.logger.info(f"[Step 5/6] Creating MKV with FLAC audio for YouTube (~1 minute)...")
         self.encode_lossless_mkv(output_files["final_karaoke_lossless_mp4"], output_files["final_karaoke_lossless_mkv"])
+        
+        self.logger.info(f"[Step 6/6] Encoding 720p version (~3 minutes)...")
         self.encode_720p_version(output_files["final_karaoke_lossless_mp4"], output_files["final_karaoke_lossy_720p_mp4"])
 
         # Skip user confirmation in non-interactive mode for Modal deployment
@@ -1668,11 +1679,17 @@ class KaraokeFinalise:
         if self.dry_run:
             self.logger.warning("Dry run enabled. No actions will be performed.")
 
+        self.logger.info("=" * 60)
+        self.logger.info("Starting KaraokeFinalise processing pipeline")
+        self.logger.info("=" * 60)
+
         # Check required input files and parameters exist, get user to confirm features before proceeding
         self.validate_input_parameters_for_features()
 
         with_vocals_file = self.find_with_vocals_file()
         base_name, artist, title = self.get_names_from_withvocals(with_vocals_file)
+        
+        self.logger.info(f"Processing: {artist} - {title}")
 
         # Use the selected instrumental file if provided, otherwise search for one
         if self.selected_instrumental_file:
@@ -1688,13 +1705,20 @@ class KaraokeFinalise:
         output_files = self.prepare_output_filenames(base_name)
 
         if self.enable_cdg:
+            self.logger.info("Creating CDG package...")
             self.create_cdg_zip_file(input_files, output_files, artist, title)
+            self.logger.info("CDG package created successfully")
 
         if self.enable_txt:
+            self.logger.info("Creating TXT package...")
             self.create_txt_zip_file(input_files, output_files)
+            self.logger.info("TXT package created successfully")
 
+        self.logger.info("Starting video encoding (this is the longest step, ~15-20 minutes)...")
         self.remux_and_encode_output_video_files(with_vocals_file, input_files, output_files)
+        self.logger.info("Video encoding completed successfully")
 
+        self.logger.info("Executing distribution features (YouTube, Dropbox, Discord)...")
         self.execute_optional_features(artist, title, base_name, input_files, output_files, replace_existing)
 
         result = {

{karaoke_gen-0.71.17 → karaoke_gen-0.71.29}/karaoke_gen/utils/remote_cli.py

@@ -143,6 +143,70 @@ class RemoteKaraokeClient:
         response = self.session.request(method, url, **kwargs)
         return response
     
+    def _upload_file_to_signed_url(self, signed_url: str, file_path: str, content_type: str) -> bool:
+        """
+        Upload a file directly to GCS using a signed URL.
+        
+        Args:
+            signed_url: The signed URL from the backend
+            file_path: Local path to the file to upload
+            content_type: MIME type for the Content-Type header
+            
+        Returns:
+            True if upload succeeded, False otherwise
+        """
+        try:
+            with open(file_path, 'rb') as f:
+                # Use a fresh requests session (not self.session) because
+                # signed URLs should not have our auth headers
+                response = requests.put(
+                    signed_url,
+                    data=f,
+                    headers={'Content-Type': content_type},
+                    timeout=600  # 10 minutes for large files
+                )
+            
+            if response.status_code in (200, 201):
+                return True
+            else:
+                self.logger.error(f"Failed to upload to signed URL: HTTP {response.status_code} - {response.text}")
+                return False
+        except Exception as e:
+            self.logger.error(f"Error uploading to signed URL: {e}")
+            return False
+    
+    def _get_content_type(self, file_path: str) -> str:
+        """Get the MIME content type for a file based on its extension."""
+        ext = Path(file_path).suffix.lower()
+        
+        content_types = {
+            # Audio
+            '.mp3': 'audio/mpeg',
+            '.wav': 'audio/wav',
+            '.flac': 'audio/flac',
+            '.m4a': 'audio/mp4',
+            '.ogg': 'audio/ogg',
+            '.aac': 'audio/aac',
+            # Images
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.webp': 'image/webp',
+            # Fonts
+            '.ttf': 'font/ttf',
+            '.otf': 'font/otf',
+            '.woff': 'font/woff',
+            '.woff2': 'font/woff2',
+            # Other
+            '.json': 'application/json',
+            '.txt': 'text/plain',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            '.rtf': 'application/rtf',
+        }
+        
+        return content_types.get(ext, 'application/octet-stream')
+    
     def _parse_style_params(self, style_params_path: str) -> Dict[str, str]:
         """
         Parse style_params.json and extract file paths that need to be uploaded.
@@ -199,10 +263,26 @@ class RemoteKaraokeClient:
         # Native API distribution (uses server-side credentials)
         dropbox_path: Optional[str] = None,
         gdrive_folder_id: Optional[str] = None,
+        # Lyrics configuration
+        lyrics_artist: Optional[str] = None,
+        lyrics_title: Optional[str] = None,
+        lyrics_file: Optional[str] = None,
+        subtitle_offset_ms: int = 0,
+        # Audio separation model configuration
+        clean_instrumental_model: Optional[str] = None,
+        backing_vocals_models: Optional[list] = None,
+        other_stems_models: Optional[list] = None,
+        # Existing instrumental (Batch 3)
+        existing_instrumental: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Submit a new karaoke generation job with optional style configuration.
         
+        Uses signed URL upload flow to bypass Cloud Run's 32MB request body limit:
+        1. Create job and get signed upload URLs from backend
+        2. Upload files directly to GCS using signed URLs
+        3. Notify backend that uploads are complete to start processing
+        
         Args:
             filepath: Path to audio file
             artist: Artist name
@@ -217,6 +297,14 @@ class RemoteKaraokeClient:
             enable_youtube_upload: Enable YouTube upload
             dropbox_path: Dropbox folder path for organized output (native API)
             gdrive_folder_id: Google Drive folder ID for public share (native API)
+            lyrics_artist: Override artist name for lyrics search
+            lyrics_title: Override title for lyrics search
+            lyrics_file: Path to user-provided lyrics file
+            subtitle_offset_ms: Subtitle timing offset in milliseconds
+            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.)
+            existing_instrumental: Path to existing instrumental file to use instead of AI separation
         """
         file_path = Path(filepath)
         
@@ -230,95 +318,168 @@ class RemoteKaraokeClient:
                 f"Allowed: {', '.join(self.ALLOWED_AUDIO_EXTENSIONS)}"
             )
         
-        self.logger.info(f"Uploading audio file: {filepath}")
+        # Step 1: Build list of files to upload
+        files_info = []
+        local_files = {}  # file_type -> local_path
+        
+        # Main audio file
+        audio_content_type = self._get_content_type(filepath)
+        files_info.append({
+            'filename': file_path.name,
+            'content_type': audio_content_type,
+            'file_type': 'audio'
+        })
+        local_files['audio'] = filepath
+        self.logger.info(f"Will upload audio: {filepath}")
+        
+        # Parse style params and find referenced files
+        style_assets = {}
+        if style_params_path and os.path.isfile(style_params_path):
+            self.logger.info(f"Parsing style configuration: {style_params_path}")
+            style_assets = self._parse_style_params(style_params_path)
+            
+            # Add style_params.json
+            files_info.append({
+                'filename': Path(style_params_path).name,
+                'content_type': 'application/json',
+                'file_type': 'style_params'
+            })
+            local_files['style_params'] = style_params_path
+            self.logger.info(f"  Will upload style_params.json")
+        
+        # Add each style asset file
+        for asset_key, asset_path in style_assets.items():
+            if os.path.isfile(asset_path):
+                content_type = self._get_content_type(asset_path)
+                files_info.append({
+                    'filename': Path(asset_path).name,
+                    'content_type': content_type,
+                    'file_type': asset_key  # e.g., 'style_intro_background'
+                })
+                local_files[asset_key] = asset_path
+                self.logger.info(f"  Will upload {asset_key}: {asset_path}")
+        
+        # Add lyrics file if provided
+        if lyrics_file and os.path.isfile(lyrics_file):
+            content_type = self._get_content_type(lyrics_file)
+            files_info.append({
+                'filename': Path(lyrics_file).name,
+                'content_type': content_type,
+                'file_type': 'lyrics_file'
+            })
+            local_files['lyrics_file'] = lyrics_file
+            self.logger.info(f"Will upload lyrics file: {lyrics_file}")
+        
+        # Add existing instrumental file if provided (Batch 3)
+        if existing_instrumental and os.path.isfile(existing_instrumental):
+            content_type = self._get_content_type(existing_instrumental)
+            files_info.append({
+                'filename': Path(existing_instrumental).name,
+                'content_type': content_type,
+                'file_type': 'existing_instrumental'
+            })
+            local_files['existing_instrumental'] = existing_instrumental
+            self.logger.info(f"Will upload existing instrumental: {existing_instrumental}")
+        
+        # Step 2: Create job and get signed upload URLs
+        self.logger.info(f"Creating job at {self.config.service_url}/api/jobs/create-with-upload-urls")
+        
+        create_request = {
+            'artist': artist,
+            'title': title,
+            'files': files_info,
+            'enable_cdg': enable_cdg,
+            'enable_txt': enable_txt,
+        }
         
-        # Prepare files dict for multipart upload
-        files_to_upload = {}
-        files_to_close = []
+        if brand_prefix:
+            create_request['brand_prefix'] = brand_prefix
+        if discord_webhook_url:
+            create_request['discord_webhook_url'] = discord_webhook_url
+        if youtube_description:
+            create_request['youtube_description'] = youtube_description
+        if enable_youtube_upload:
+            create_request['enable_youtube_upload'] = enable_youtube_upload
+        if dropbox_path:
+            create_request['dropbox_path'] = dropbox_path
+        if gdrive_folder_id:
+            create_request['gdrive_folder_id'] = gdrive_folder_id
+        if organised_dir_rclone_root:
+            create_request['organised_dir_rclone_root'] = organised_dir_rclone_root
+        if lyrics_artist:
+            create_request['lyrics_artist'] = lyrics_artist
+        if lyrics_title:
+            create_request['lyrics_title'] = lyrics_title
+        if subtitle_offset_ms != 0:
+            create_request['subtitle_offset_ms'] = subtitle_offset_ms
+        if clean_instrumental_model:
+            create_request['clean_instrumental_model'] = clean_instrumental_model
+        if backing_vocals_models:
+            create_request['backing_vocals_models'] = backing_vocals_models
+        if other_stems_models:
+            create_request['other_stems_models'] = other_stems_models
+        
+        response = self._request('POST', '/api/jobs/create-with-upload-urls', json=create_request)
         
-        try:
-            # Main audio file
-            audio_file = open(filepath, 'rb')
-            files_to_close.append(audio_file)
-            files_to_upload['file'] = (file_path.name, audio_file)
-            
-            # Parse style params and find referenced files
-            style_assets = {}
-            if style_params_path and os.path.isfile(style_params_path):
-                self.logger.info(f"Parsing style configuration: {style_params_path}")
-                style_assets = self._parse_style_params(style_params_path)
-                
-                # Upload style_params.json
-                style_file = open(style_params_path, 'rb')
-                files_to_close.append(style_file)
-                files_to_upload['style_params'] = (Path(style_params_path).name, style_file, 'application/json')
-                self.logger.info(f"  Will upload style_params.json")
-            
-            # Upload each style asset file
-            for asset_key, asset_path in style_assets.items():
-                if os.path.isfile(asset_path):
-                    asset_file = open(asset_path, 'rb')
-                    files_to_close.append(asset_file)
-                    # Determine content type
-                    ext = Path(asset_path).suffix.lower()
-                    if ext in self.ALLOWED_IMAGE_EXTENSIONS:
-                        content_type = f'image/{ext[1:]}'
-                    elif ext in self.ALLOWED_FONT_EXTENSIONS:
-                        content_type = 'font/ttf'
-                    else:
-                        content_type = 'application/octet-stream'
-                    files_to_upload[asset_key] = (Path(asset_path).name, asset_file, content_type)
-                    self.logger.info(f"  Will upload {asset_key}: {asset_path}")
-            
-            # Prepare form data
-            data = {
-                'artist': artist,
-                'title': title,
-                'enable_cdg': str(enable_cdg).lower(),
-                'enable_txt': str(enable_txt).lower(),
-            }
-            
-            if brand_prefix:
-                data['brand_prefix'] = brand_prefix
-            if discord_webhook_url:
-                data['discord_webhook_url'] = discord_webhook_url
-            if youtube_description:
-                data['youtube_description'] = youtube_description
-            if enable_youtube_upload:
-                data['enable_youtube_upload'] = str(enable_youtube_upload).lower()
-            
-            # Native API distribution (preferred for remote CLI)
-            if dropbox_path:
-                data['dropbox_path'] = dropbox_path
-            if gdrive_folder_id:
-                data['gdrive_folder_id'] = gdrive_folder_id
+        if response.status_code != 200:
+            try:
+                error_detail = response.json()
+            except Exception:
+                error_detail = response.text
+            raise RuntimeError(f"Error creating job: {error_detail}")
+        
+        create_result = response.json()
+        if create_result.get('status') != 'success':
+            raise RuntimeError(f"Error creating job: {create_result}")
+        
+        job_id = create_result['job_id']
+        upload_urls = create_result['upload_urls']
+        
+        self.logger.info(f"Job {job_id} created. Uploading {len(upload_urls)} files directly to storage...")
+        
+        # Step 3: Upload each file directly to GCS using signed URLs
+        uploaded_files = []
+        for url_info in upload_urls:
+            file_type = url_info['file_type']
+            signed_url = url_info['upload_url']
+            content_type = url_info['content_type']
+            local_path = local_files.get(file_type)
             
-            # Legacy rclone distribution (deprecated)
-            if organised_dir_rclone_root:
-                data['organised_dir_rclone_root'] = organised_dir_rclone_root
+            if not local_path:
+                self.logger.warning(f"No local file found for file_type: {file_type}")
+                continue
             
-            self.logger.info(f"Submitting job to {self.config.service_url}/api/jobs/upload")
+            # Calculate file size for logging
+            file_size = os.path.getsize(local_path)
+            file_size_mb = file_size / (1024 * 1024)
+            self.logger.info(f"  Uploading {file_type} ({file_size_mb:.1f} MB)...")
             
-            response = self._request('POST', '/api/jobs/upload', files=files_to_upload, data=data)
+            success = self._upload_file_to_signed_url(signed_url, local_path, content_type)
+            if not success:
+                raise RuntimeError(f"Failed to upload {file_type} to storage")
             
-        finally:
-            # Close all opened files
-            for f in files_to_close:
-                try:
-                    f.close()
-                except:
-                    pass
+            uploaded_files.append(file_type)
+            self.logger.info(f"  ✓ Uploaded {file_type}")
+        
+        # Step 4: Notify backend that uploads are complete
+        self.logger.info(f"Notifying backend that uploads are complete...")
+        
+        complete_request = {
+            'uploaded_files': uploaded_files
+        }
+        
+        response = self._request('POST', f'/api/jobs/{job_id}/uploads-complete', json=complete_request)
         
         if response.status_code != 200:
             try:
                 error_detail = response.json()
             except Exception:
                 error_detail = response.text
-            raise RuntimeError(f"Error submitting job: {error_detail}")
+            raise RuntimeError(f"Error completing uploads: {error_detail}")
         
         result = response.json()
         if result.get('status') != 'success':
-            raise RuntimeError(f"Error submitting job: {result}")
+            raise RuntimeError(f"Error completing uploads: {result}")
         
         # Log distribution services info if available
         if 'distribution_services' in result:
@@ -610,6 +771,40 @@ class JobMonitor:
         self._last_timeline_index = 0
         self._last_log_index = 0
         self._show_worker_logs = True  # Enable worker log display
+        self._polls_without_updates = 0  # Track polling activity for heartbeat
+        self._heartbeat_interval = 6  # Show heartbeat every N polls without updates (~30s with 5s poll)
+    
+    # Status descriptions for user-friendly logging
+    STATUS_DESCRIPTIONS = {
+        'pending': 'Job queued, waiting to start',
+        'downloading': 'Downloading and preparing input files',
+        'separating_stage1': 'AI audio separation (stage 1 of 2)',
+        'separating_stage2': 'AI audio separation (stage 2 of 2)',
+        'audio_complete': 'Audio separation complete',
+        'transcribing': 'Transcribing lyrics from audio',
+        'correcting': 'Auto-correcting lyrics against reference sources',
+        'lyrics_complete': 'Lyrics processing complete',
+        'generating_screens': 'Creating title and end screens',
+        'applying_padding': 'Adding intro/outro padding',
+        'awaiting_review': 'Waiting for lyrics review',
+        'in_review': 'Lyrics review in progress',
+        'review_complete': 'Review complete, preparing video render',
+        'rendering_video': 'Rendering karaoke video with lyrics',
+        'awaiting_instrumental_selection': 'Waiting for instrumental selection',
+        'instrumental_selected': 'Instrumental selected, preparing final encoding',
+        'generating_video': 'Downloading files for final video encoding',
+        'encoding': 'Encoding final videos (15-20 min, 4 formats)',
+        'packaging': 'Creating CDG/TXT packages',
+        'uploading': 'Uploading to distribution services',
+        'notifying': 'Sending notifications',
+        'complete': 'All processing complete',
+        'failed': 'Job failed',
+        'cancelled': 'Job cancelled',
+    }
+    
+    def _get_status_description(self, status: str) -> str:
+        """Get user-friendly description for a status."""
+        return self.STATUS_DESCRIPTIONS.get(status, status)
     
     def open_browser(self, url: str) -> None:
         """Open URL in the default browser."""
@@ -1101,6 +1296,7 @@ class JobMonitor:
         
         self.logger.info(f"Monitoring job: {job_id}")
         self.logger.info(f"Service URL: {self.config.service_url}")
+        self.logger.info(f"Polling every {self.config.poll_interval} seconds...")
         self.logger.info("")
         
         while True:
@@ -1111,16 +1307,40 @@ class JobMonitor:
                 artist = job_data.get('artist', '')
                 title = job_data.get('title', '')
                 
+                # Track whether we got any new updates this poll
+                had_updates = False
+                prev_timeline_index = self._last_timeline_index
+                prev_log_index = self._last_log_index
+                
                 # Log timeline updates (shows status changes and progress)
                 self.log_timeline_updates(job_data)
+                if self._last_timeline_index > prev_timeline_index:
+                    had_updates = True
                 
                 # Log worker logs (shows detailed worker output for debugging)
                 self.log_worker_logs(job_id)
+                if self._last_log_index > prev_log_index:
+                    had_updates = True
                 
-                # Log status changes
+                # Log status changes with user-friendly descriptions
                 if status != last_status:
-                    self.logger.info(f"Status changed: {last_status} -> {status}")
+                    description = self._get_status_description(status)
+                    if last_status:
+                        self.logger.info(f"Status: {status} - {description}")
+                    else:
+                        self.logger.info(f"Current status: {status} - {description}")
                     last_status = status
+                    had_updates = True
+                
+                # Heartbeat: if no updates for a while, show we're still alive
+                if had_updates:
+                    self._polls_without_updates = 0
+                else:
+                    self._polls_without_updates += 1
+                    if self._polls_without_updates >= self._heartbeat_interval:
+                        description = self._get_status_description(status)
+                        self.logger.info(f"  [Still processing: {description}]")
+                        self._polls_without_updates = 0
                 
                 # Handle human interaction points
                 if status in ['awaiting_review', 'in_review']:
@@ -1559,8 +1779,6 @@ def main():
         ignored_features.append("--skip-transcription")
     if args.lyrics_only:
         ignored_features.append("--lyrics-only")
-    if args.existing_instrumental:
-        ignored_features.append("--existing_instrumental")
     if args.background_video:
         ignored_features.append("--background_video")
     if getattr(args, 'auto_download', False):
@@ -1655,6 +1873,24 @@ def main():
         logger.info(f"Dropbox (rclone): {args.organised_dir_rclone_root}")
     if args.discord_webhook_url:
         logger.info(f"Discord: enabled")
+    # Lyrics configuration
+    if getattr(args, 'lyrics_artist', None):
+        logger.info(f"Lyrics Artist Override: {args.lyrics_artist}")
+    if getattr(args, 'lyrics_title', None):
+        logger.info(f"Lyrics Title Override: {args.lyrics_title}")
+    if getattr(args, 'lyrics_file', None):
+        logger.info(f"Lyrics File: {args.lyrics_file}")
+    if getattr(args, 'subtitle_offset_ms', 0):
+        logger.info(f"Subtitle Offset: {args.subtitle_offset_ms}ms")
+    # Audio model configuration
+    if getattr(args, 'clean_instrumental_model', None):
+        logger.info(f"Clean Instrumental Model: {args.clean_instrumental_model}")
+    if getattr(args, 'backing_vocals_models', None):
+        logger.info(f"Backing Vocals Models: {args.backing_vocals_models}")
+    if getattr(args, 'other_stems_models', None):
+        logger.info(f"Other Stems Models: {args.other_stems_models}")
+    if getattr(args, 'existing_instrumental', None):
+        logger.info(f"Existing Instrumental: {args.existing_instrumental}")
     logger.info(f"Service URL: {config.service_url}")
     logger.info(f"Review UI: {config.review_ui_url}")
     if config.non_interactive:
@@ -1688,6 +1924,17 @@ def main():
             # Native API distribution (preferred for remote CLI)
             dropbox_path=getattr(args, 'dropbox_path', None),
             gdrive_folder_id=getattr(args, 'gdrive_folder_id', None),
+            # Lyrics configuration
+            lyrics_artist=getattr(args, 'lyrics_artist', None),
+            lyrics_title=getattr(args, 'lyrics_title', None),
+            lyrics_file=getattr(args, 'lyrics_file', None),
+            subtitle_offset_ms=getattr(args, 'subtitle_offset_ms', 0) or 0,
+            # Audio separation model configuration
+            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),
+            # Existing instrumental (Batch 3)
+            existing_instrumental=getattr(args, 'existing_instrumental', None),
         )
         job_id = result.get('job_id')
         style_assets = result.get('style_assets_uploaded', [])