karaoke-gen 0.71.23__py3-none-any.whl → 0.71.27__py3-none-any.whl

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.
@@ -204,10 +268,21 @@ class RemoteKaraokeClient:
         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
@@ -226,6 +301,10 @@ class RemoteKaraokeClient:
             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)
         
@@ -239,110 +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}")
-            
-            # Upload lyrics file if provided
-            if lyrics_file and os.path.isfile(lyrics_file):
-                self.logger.info(f"Uploading lyrics file: {lyrics_file}")
-                lyrics_file_handle = open(lyrics_file, 'rb')
-                files_to_close.append(lyrics_file_handle)
-                files_to_upload['lyrics_file'] = (Path(lyrics_file).name, lyrics_file_handle, 'text/plain')
-            
-            # 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
-            
-            # Legacy rclone distribution (deprecated)
-            if organised_dir_rclone_root:
-                data['organised_dir_rclone_root'] = organised_dir_rclone_root
+        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)
             
-            # Lyrics configuration
-            if lyrics_artist:
-                data['lyrics_artist'] = lyrics_artist
-            if lyrics_title:
-                data['lyrics_title'] = lyrics_title
-            if subtitle_offset_ms != 0:
-                data['subtitle_offset_ms'] = str(subtitle_offset_ms)
+            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:
@@ -1642,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):
@@ -1747,6 +1882,15 @@ def main():
         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:
@@ -1785,6 +1929,12 @@ def main():
             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', [])

{karaoke_gen-0.71.23.dist-info → karaoke_gen-0.71.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karaoke-gen
-Version: 0.71.23
+Version: 0.71.27
 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.23.dist-info → karaoke_gen-0.71.27.dist-info}/RECORD

@@ -30,7 +30,7 @@ karaoke_gen/utils/__init__.py,sha256=FpOHyeBRB06f3zMoLBUJHTDZACrabg-DoyBTxNKYyNY
 karaoke_gen/utils/bulk_cli.py,sha256=bBRHfhvi-wkoNjAoq5rzVkaOwOraoiUhXNQY5rBsX18,19167
 karaoke_gen/utils/cli_args.py,sha256=jfU6QXfzDlqZiLs58EC5eQs970tkI3-zSN2dKqW3u00,17618
 karaoke_gen/utils/gen_cli.py,sha256=8TQsu8Ubd-aKeQMHBH4-j65seGnR9IBjmi-OQwR0GAA,25775
-karaoke_gen/utils/remote_cli.py,sha256=DUzSTkG3R5FrZMQvi_e01NPGXvdKOGkpnEE1sJMeaEg,76648
+karaoke_gen/utils/remote_cli.py,sha256=IwJRZNwVF_qmAOYoV9PVQlnTd39WtEycRicmdCa5Wxg,83306
 karaoke_gen/video_background_processor.py,sha256=p3sryMxmkori4Uy2MYgmlk5_QQ7Uh9IoVJLAdkdLIUI,15124
 karaoke_gen/video_generator.py,sha256=B7BQBrjkyvk3L3sctnPXnvr1rzkw0NYx5UCAl0ZiVx0,18464
 lyrics_transcriber/__init__.py,sha256=g9ZbJg9U1qo7XzrC25J3bTKcNzzwUJWDVdi_7-hjcM4,412
@@ -268,8 +268,8 @@ lyrics_transcriber/transcribers/whisper.py,sha256=YcCB1ic9H6zL1GS0jD0emu8-qlcH0Q
 lyrics_transcriber/types.py,sha256=Y7WUx8PAOBYWCIZgw4ndeHfPH8Gg--O3OYYQgMpJ2iI,27728
 lyrics_transcriber/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyrics_transcriber/utils/word_utils.py,sha256=-cMGpj9UV4F6IsoDKAV2i1aiqSO8eI91HMAm_igtVMk,958
-karaoke_gen-0.71.23.dist-info/METADATA,sha256=c269LSFEjwPZaZLJUT5GNOr655lF_dZuNtCHBnNlDWA,16948
-karaoke_gen-0.71.23.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-karaoke_gen-0.71.23.dist-info/entry_points.txt,sha256=xIyLe7K84ZyjO8L0_AmNectz93QjGSs5AkApMtlAd4g,160
-karaoke_gen-0.71.23.dist-info/licenses/LICENSE,sha256=81R_4XwMZDODHD7JcZeUR8IiCU8AD7Ajl6bmwR9tYDk,1074
-karaoke_gen-0.71.23.dist-info/RECORD,,
+karaoke_gen-0.71.27.dist-info/METADATA,sha256=xuqeNzosJwGo41JXO1BSjpcouoJjYHAyJwtlGXML_YU,16948
+karaoke_gen-0.71.27.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+karaoke_gen-0.71.27.dist-info/entry_points.txt,sha256=xIyLe7K84ZyjO8L0_AmNectz93QjGSs5AkApMtlAd4g,160
+karaoke_gen-0.71.27.dist-info/licenses/LICENSE,sha256=81R_4XwMZDODHD7JcZeUR8IiCU8AD7Ajl6bmwR9tYDk,1074
+karaoke_gen-0.71.27.dist-info/RECORD,,