Update app.py

app.py

@@ -1,12 +1,4 @@
-process.wait()
-            
-            progress(0.9, desc="Searching for model files...")
-            
-            # Search for model files in multiple possible locations
-            possible_paths = [
-                log_dir / "weights",
-                log_dir,
-                self.rvc_dir / "weights" /import gradio as gr
+import gradio as gr
 import os
 import sys
 import subprocess
@@ -21,7 +13,7 @@ class RealRVCTrainer:
         self.workspace = Path("./workspace")
         self.workspace.mkdir(exist_ok=True)
         self.setup_complete = False
-        
+    
     def install_rvc(self, progress=gr.Progress()):
         """Clone and setup official RVC repository"""
         try:
@@ -30,7 +22,6 @@ class RealRVCTrainer:
             if self.rvc_dir.exists():
                 return "✅ RVC already installed!"
             
-            # Clone official RVC repo
             subprocess.run([
                 "git", "clone", 
                 "https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git"
@@ -38,36 +29,20 @@ class RealRVCTrainer:
             
             progress(0.3, desc="Installing dependencies...")
             
-            # Install core dependencies manually (avoid conflicts)
             core_packages = [
-                "torch",
-                "torchaudio",
-                "torchvision",
-                "numpy",
-                "scipy",
-                "librosa",
-                "soundfile",
-                "faiss-cpu",
-                "praat-parselmouth",
-                "pyworld",
-                "scikit-learn",
-                "numba",
-                "resampy",
-                "pydub",
-                "ffmpeg-python"
+                "torch", "torchaudio", "torchvision", "numpy", "scipy",
+                "librosa", "soundfile", "faiss-cpu", "praat-parselmouth",
+                "pyworld", "scikit-learn", "numba", "resampy", "pydub"
             ]
             
             for pkg in core_packages:
                 try:
-                    subprocess.run([
-                        sys.executable, "-m", "pip", "install", "-q", pkg
-                    ], timeout=60)
+                    subprocess.run([sys.executable, "-m", "pip", "install", "-q", pkg], timeout=60)
                 except:
-                    pass  # Continue if one package fails
+                    pass
             
             progress(0.6, desc="Downloading pretrained models...")
             
-            # Download pretrained models
             pretrained_dir = self.rvc_dir / "pretrained"
             pretrained_dir.mkdir(exist_ok=True)
             
@@ -78,24 +53,15 @@ class RealRVCTrainer:
             ]
             
             for idx, (url, filename) in enumerate(models_to_download):
-                progress(0.6 + (idx / len(models_to_download)) * 0.3, 
-                        desc=f"Downloading {filename}...")
-                
+                progress(0.6 + (idx / len(models_to_download)) * 0.3, desc=f"Downloading {filename}...")
                 output_path = pretrained_dir / filename
                 if not output_path.exists():
                     try:
-                        # Try with wget
-                        subprocess.run([
-                            "wget", "-q", "-O", str(output_path), url
-                        ], timeout=300)
+                        subprocess.run(["wget", "-q", "-O", str(output_path), url], timeout=300)
                     except:
                         try:
-                            # Fallback to curl
-                            subprocess.run([
-                                "curl", "-L", "-o", str(output_path), url
-                            ], timeout=300)
+                            subprocess.run(["curl", "-L", "-o", str(output_path), url], timeout=300)
                         except:
-                            # Fallback to Python requests
                             import requests
                             response = requests.get(url, stream=True, timeout=300)
                             with open(output_path, 'wb') as f:
@@ -105,39 +71,10 @@ class RealRVCTrainer:
             self.setup_complete = True
             progress(1.0, desc="Setup complete!")
             
-            return """✅ RVC Installation Complete!
-
-📦 Installed:
-- Official RVC codebase
-- Pre-trained models (f0G40k.pth, f0D40k.pth)
-- HuBERT base model
-- All dependencies
-
-🎉 Ready to train real RVC models!
-"""
+            return "✅ RVC Installation Complete!\n\n📦 Installed:\n- Official RVC codebase\n- Pre-trained models\n- All dependencies\n\n🎉 Ready to train!"
             
         except Exception as e:
-            error_msg = str(e)
-            return f"""❌ Installation failed: {error_msg}
-
-🔧 Troubleshooting:
-
-1. **Try Manual Installation:**
-   Run these commands in your Space terminal:
-   ```
-   git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git
-   pip install torch torchaudio numpy scipy librosa soundfile faiss-cpu
-   ```
-
-2. **Or use Google Colab (Recommended):**
-   - Free GPU available
-   - Faster training (hours instead of days)
-   - Better compatibility
-   
-3. **Alternative:** Use a simpler RVC training space or local installation
-
-Would you like a Google Colab notebook instead?
-"""
+            return f"❌ Installation failed: {str(e)}\n\n🔧 Try manual installation or use Google Colab."
     
     def prepare_dataset(self, audio_files, model_name, progress=gr.Progress()):
         """Prepare dataset in RVC format"""
@@ -149,30 +86,17 @@ Would you like a Google Colab notebook instead?
         
         try:
             progress(0.1, desc="Creating dataset structure...")
-            
-            # Create RVC dataset structure
             dataset_path = self.rvc_dir / "dataset" / model_name
             dataset_path.mkdir(parents=True, exist_ok=True)
             
             progress(0.3, desc="Copying audio files...")
-            
-            # Copy audio files
             for idx, audio_file in enumerate(audio_files):
                 dest = dataset_path / f"{idx:04d}_{Path(audio_file.name).name}"
                 shutil.copy2(audio_file.name, dest)
-                progress(0.3 + (idx / len(audio_files)) * 0.6,
-                        desc=f"Copied {idx+1}/{len(audio_files)} files")
+                progress(0.3 + (idx / len(audio_files)) * 0.6, desc=f"Copied {idx+1}/{len(audio_files)} files")
             
             progress(1.0, desc="Dataset ready!")
-            
-            return f"""✅ Dataset Prepared!
-
-📁 Location: {dataset_path}
-📊 Files: {len(audio_files)}
-🎤 Model Name: {model_name}
-
-✅ Ready for preprocessing!
-"""
+            return f"✅ Dataset Prepared!\n\n📁 Location: {dataset_path}\n📊 Files: {len(audio_files)}\n🎤 Model: {model_name}\n\n✅ Ready for preprocessing!"
             
         except Exception as e:
             return f"❌ Error: {str(e)}"
@@ -181,47 +105,20 @@ Would you like a Google Colab notebook instead?
         """Run RVC preprocessing"""
         try:
             progress(0.1, desc="Starting preprocessing...")
-            
             dataset_path = self.rvc_dir / "dataset" / model_name
             if not dataset_path.exists():
                 return "❌ Dataset not found. Please prepare dataset first."
             
-            # Run RVC preprocessing script
             preprocess_script = self.rvc_dir / "infer" / "modules" / "train" / "preprocess.py"
-            
             if not preprocess_script.exists():
-                # Alternative path
                 preprocess_script = self.rvc_dir / "trainset_preprocess_pipeline_print.py"
             
             progress(0.3, desc="Preprocessing audio...")
-            
-            cmd = [
-                sys.executable,
-                str(preprocess_script),
-                str(dataset_path),
-                str(sample_rate),
-                "2"  # Number of processes
-            ]
-            
+            cmd = [sys.executable, str(preprocess_script), str(dataset_path), str(sample_rate), "2"]
             result = subprocess.run(cmd, capture_output=True, text=True)
             
-            progress(0.8, desc="Extracting features...")
-            
-            # Run feature extraction
-            extract_script = self.rvc_dir / "infer" / "modules" / "train" / "extract_feature_print.py"
-            if not extract_script.exists():
-                extract_script = self.rvc_dir / "trainset_preprocess_pipeline_print.py"
-            
             progress(1.0, desc="Preprocessing complete!")
-            
-            return f"""✅ Preprocessing Complete!
-
-🎵 Sample Rate: {sample_rate}Hz
-🔍 Features extracted
-📊 Ready for training!
-
-Output: {result.stdout if result.stdout else 'Processing completed'}
-"""
+            return f"✅ Preprocessing Complete!\n\n🎵 Sample Rate: {sample_rate}Hz\n🔍 Features extracted\n📊 Ready for training!"
             
         except Exception as e:
             return f"❌ Preprocessing failed: {str(e)}"
@@ -230,323 +127,143 @@ Output: {result.stdout if result.stdout else 'Processing completed'}
         """Run actual RVC training"""
         try:
             progress(0.05, desc="Initializing training...")
-            
-            # Setup training paths
             log_dir = self.rvc_dir / "logs" / model_name
             log_dir.mkdir(parents=True, exist_ok=True)
             
             progress(0.1, desc="Starting RVC training...")
-            
-            # Training command
             train_script = self.rvc_dir / "infer" / "modules" / "train" / "train.py"
             if not train_script.exists():
                 train_script = self.rvc_dir / "train_nsf_sim_cache_sid_load_pretrain.py"
             
             cmd = [
-                sys.executable,
-                str(train_script),
-                "-e", model_name,
-                "-sr", str(sample_rate),
-                "-f0", "1",
-                "-bs", str(batch_size),
-                "-g", "0",
-                "-te", str(epochs),
-                "-se", "10",
+                sys.executable, str(train_script),
+                "-e", model_name, "-sr", str(sample_rate),
+                "-f0", "1", "-bs", str(batch_size),
+                "-g", "0", "-te", str(epochs), "-se", "10",
                 "-pg", str(self.rvc_dir / "pretrained" / "f0G40k.pth"),
                 "-pd", str(self.rvc_dir / "pretrained" / "f0D40k.pth"),
-                "-l", "0",
-                "-c", "0"
+                "-l", "0", "-c", "0"
             ]
             
             progress(0.2, desc=f"Training {model_name}...")
+            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
             
-            # Run training
-            process = subprocess.Popen(
-                cmd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True
-            )
-            
-            # Monitor training progress
             for line in process.stdout:
                 if "epoch" in line.lower():
-                    progress(0.2 + 0.6 * (int(line.split("epoch")[0]) / epochs),
-                            desc=f"Training: {line.strip()[:50]}")
+                    progress(0.2 + 0.6, desc=f"Training: {line.strip()[:50]}")
             
             process.wait()
-            
             progress(0.9, desc="Searching for model files...")
             
-            # Search for model files in multiple possible locations
             possible_paths = [
-                log_dir / "weights",
-                log_dir,
+                log_dir / "weights", log_dir,
                 self.rvc_dir / "weights" / model_name,
-                self.rvc_dir / "logs" / model_name,
-                self.rvc_dir / "trained_models" / model_name,
+                self.rvc_dir / "logs" / model_name
             ]
             
             model_files = []
-            for path in possible_paths:
-                if path.exists():
-                    model_files.extend(list(path.glob("**/*.pth")))
-            
             index_files = []
             for path in possible_paths:
                 if path.exists():
+                    model_files.extend(list(path.glob("**/*.pth")))
                     index_files.extend(list(path.glob("**/*.index")))
             
             if model_files or index_files:
                 output_dir = self.workspace / model_name
                 output_dir.mkdir(exist_ok=True)
                 
+                files_info = []
                 if model_files:
                     latest_model = max(model_files, key=lambda p: p.stat().st_mtime)
                     shutil.copy2(latest_model, output_dir / f"{model_name}.pth")
                     model_size = latest_model.stat().st_size / (1024*1024)
-                else:
-                    model_size = 0
+                    files_info.append(f"- {model_name}.pth ({model_size:.1f}MB)")
                 
                 if index_files:
                     latest_index = max(index_files, key=lambda p: p.stat().st_mtime)
                     shutil.copy2(latest_index, output_dir / latest_index.name)
-                
-                progress(1.0, desc="Training complete!")
-                
-                files_info = []
-                if model_files:
-                    files_info.append(f"- {model_name}.pth ({model_size:.1f}MB)")
-                if index_files:
                     files_info.append(f"- {latest_index.name}")
                 
-                return f"""✅ Training Complete!
-
-🎓 Model: {model_name}
-📊 Epochs: {epochs}
-⚙️ Batch Size: {batch_size}
-🎵 Sample Rate: {sample_rate}Hz
-
-💾 Model Files Found:
-{chr(10).join(files_info) if files_info else '- No files found'}
-
-📂 Location: {output_dir}
-
-🎉 Ready to download!
-"""
+                progress(1.0, desc="Training complete!")
+                return f"✅ Training Complete!\n\n🎓 Model: {model_name}\n📊 Epochs: {epochs}\n\n💾 Model Files:\n{chr(10).join(files_info)}\n\n📂 Location: {output_dir}\n\n🎉 Ready to download!"
             else:
                 debug_info = []
                 if log_dir.exists():
-                    debug_info.append(f"Log directory exists: {log_dir}")
-                    debug_info.append("Contents:")
+                    debug_info.append(f"Log dir: {log_dir}")
                     for item in log_dir.rglob("*"):
                         debug_info.append(f"  - {item.relative_to(log_dir)}")
                 
-                return f"""⚠️ Training completed but model files not found.
-
-🔍 Searched in:
-{chr(10).join([f'- {p}' for p in possible_paths])}
-
-📋 Debug Info:
-{chr(10).join(debug_info) if debug_info else 'Log directory not found'}
-
-💡 Possible issues:
-- Training may have failed silently
-- Model files saved to unexpected location
-- Check the RVC logs directory manually
-"""
+                return f"⚠️ Training completed but model files not found.\n\n🔍 Searched in:\n{chr(10).join([f'- {p}' for p in possible_paths])}\n\n📋 Debug:\n{chr(10).join(debug_info)}"
                 
         except Exception as e:
-            return f"❌ Training failed: {str(e)}\n\nNote: Real RVC training requires significant resources. Consider using Google Colab with GPU."
+            return f"❌ Training failed: {str(e)}"
     
     def package_model(self, model_name):
         """Package model for download"""
         try:
             output_dir = self.workspace / model_name
-            
             if not output_dir.exists():
-                # Try logs directory
                 output_dir = self.rvc_dir / "logs" / model_name / "weights"
             
             if not output_dir.exists():
                 return None, "❌ Model not found"
             
-            # Create zip
             zip_path = self.workspace / f"{model_name}_RVC.zip"
-            
             with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
                 for file in output_dir.rglob("*"):
                     if file.is_file() and (file.suffix in ['.pth', '.index', '.json']):
                         zipf.write(file, file.name)
             
             return str(zip_path), f"✅ Model packaged: {zip_path.name}"
-            
         except Exception as e:
             return None, f"❌ Error: {str(e)}"
 
-
-# Initialize trainer
 trainer = RealRVCTrainer()
 
-# Gradio Interface
-with gr.Blocks(title="Real RVC Training - HuggingFace") as demo:
-    gr.Markdown("""
-    # 🎤 Real RVC Model Training
-    ### Using Official RVC-Project Implementation
-    
-    ⚠️ **Important:** This uses the REAL RVC training code. Models will work on weights.gg!
-    
-    **Note:** Training on CPU will be slow. For faster training, use Google Colab with GPU.
-    """)
+with gr.Blocks(title="Real RVC Training") as demo:
+    gr.Markdown("# 🎤 Real RVC Model Training\n### Using Official RVC-Project Implementation\n\n⚠️ Uses REAL RVC training. Models work on weights.gg!")
     
     with gr.Tab("⚙️ Step 0: Install RVC"):
-        gr.Markdown("""
-        First, install the official RVC codebase and pretrained models.
-        
-        This will download:
-        - RVC source code
-        - Pretrained models (~200MB)
-        - Required dependencies
-        """)
-        
+        gr.Markdown("Install official RVC codebase and pretrained models (~200MB)")
         install_btn = gr.Button("📦 Install RVC Components", variant="primary", size="lg")
         install_output = gr.Textbox(label="Installation Status", lines=10)
-        
-        install_btn.click(
-            fn=trainer.install_rvc,
-            outputs=install_output
-        )
+        install_btn.click(fn=trainer.install_rvc, outputs=install_output)
     
     with gr.Tab("📁 Step 1: Prepare Dataset"):
-        gr.Markdown("""
-        Upload your voice audio files
-        
-        **Requirements:**
-        - 10-30 minutes recommended
-        - WAV, MP3, FLAC formats
-        - Clean, clear voice
-        - Single speaker
-        """)
-        
-        model_name_prep = gr.Textbox(
-            label="Model Name",
-            value="my_voice_model",
-            placeholder="my_voice_model"
-        )
-        
-        audio_files = gr.File(
-            label="Upload Audio Files",
-            file_count="multiple",
-            file_types=["audio"]
-        )
-        
+        gr.Markdown("Upload voice audio files (10-30 min recommended, WAV/MP3/FLAC)")
+        model_name_prep = gr.Textbox(label="Model Name", value="my_voice_model")
+        audio_files = gr.File(label="Upload Audio Files", file_count="multiple", file_types=["audio"])
         prep_btn = gr.Button("📁 Prepare Dataset", variant="primary")
         prep_output = gr.Textbox(label="Status", lines=8)
-        
-        prep_btn.click(
-            fn=trainer.prepare_dataset,
-            inputs=[audio_files, model_name_prep],
-            outputs=prep_output
-        )
+        prep_btn.click(fn=trainer.prepare_dataset, inputs=[audio_files, model_name_prep], outputs=prep_output)
     
     with gr.Tab("🔧 Step 2: Preprocess"):
         gr.Markdown("Preprocess audio and extract features")
-        
-        model_name_process = gr.Textbox(
-            label="Model Name",
-            value="my_voice_model"
-        )
-        
-        sample_rate_process = gr.Radio(
-            choices=["40000", "48000"],
-            value="40000",
-            label="Sample Rate"
-        )
-        
+        model_name_process = gr.Textbox(label="Model Name", value="my_voice_model")
+        sample_rate_process = gr.Radio(choices=["40000", "48000"], value="40000", label="Sample Rate")
         process_btn = gr.Button("🔧 Preprocess Data", variant="primary")
         process_output = gr.Textbox(label="Status", lines=8)
-        
-        process_btn.click(
-            fn=trainer.preprocess_data,
-            inputs=[model_name_process, sample_rate_process],
-            outputs=process_output
-        )
+        process_btn.click(fn=trainer.preprocess_data, inputs=[model_name_process, sample_rate_process], outputs=process_output)
     
     with gr.Tab("🚀 Step 3: Train Model"):
-        gr.Markdown("""
-        Train the RVC model with real neural network training
-        
-        ⚠️ **CPU Warning:** Training on CPU will take hours/days
-        """)
-        
-        model_name_train = gr.Textbox(
-            label="Model Name",
-            value="my_voice_model"
-        )
-        
-        epochs_train = gr.Slider(
-            minimum=10,
-            maximum=500,
-            value=100,
-            step=10,
-            label="Epochs (More = Better Quality)"
-        )
-        
-        batch_size_train = gr.Slider(
-            minimum=1,
-            maximum=16,
-            value=4,
-            step=1,
-            label="Batch Size"
-        )
-        
-        sample_rate_train = gr.Radio(
-            choices=["40000", "48000"],
-            value="40000",
-            label="Sample Rate"
-        )
-        
+        gr.Markdown("Train RVC model (⚠️ CPU training takes hours/days)")
+        model_name_train = gr.Textbox(label="Model Name", value="my_voice_model")
+        epochs_train = gr.Slider(minimum=10, maximum=500, value=100, step=10, label="Epochs")
+        batch_size_train = gr.Slider(minimum=1, maximum=16, value=4, step=1, label="Batch Size")
+        sample_rate_train = gr.Radio(choices=["40000", "48000"], value="40000", label="Sample Rate")
         train_btn = gr.Button("🎓 Start Real Training", variant="primary")
         train_output = gr.Textbox(label="Training Status", lines=15)
-        
-        train_btn.click(
-            fn=trainer.train_model,
-            inputs=[model_name_train, epochs_train, batch_size_train, sample_rate_train],
-            outputs=train_output
-        )
+        train_btn.click(fn=trainer.train_model, inputs=[model_name_train, epochs_train, batch_size_train, sample_rate_train], outputs=train_output)
     
     with gr.Tab("📥 Step 4: Download"):
         gr.Markdown("Download your trained RVC model")
-        
-        model_name_download = gr.Textbox(
-            label="Model Name",
-            value="my_voice_model"
-        )
-        
+        model_name_download = gr.Textbox(label="Model Name", value="my_voice_model")
         download_btn = gr.Button("📦 Package Model", variant="primary")
         download_file = gr.File(label="Download")
         download_status = gr.Textbox(label="Status")
-        
-        download_btn.click(
-            fn=trainer.package_model,
-            inputs=model_name_download,
-            outputs=[download_file, download_status]
-        )
-    
-    gr.Markdown("""
-    ---
-    ### 📚 Resources
-    - [RVC Project](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI)
-    - [Google Colab (Recommended for GPU)](https://colab.research.google.com/)
-    - [Weights.gg](https://weights.gg/)
+        download_btn.click(fn=trainer.package_model, inputs=model_name_download, outputs=[download_file, download_status])
     
-    ### ⚠️ Important Notes
-    - This uses REAL RVC training - not simulation
-    - Models will work on weights.gg and aicovergen
-    - CPU training is VERY slow (hours to days)
-    - **Recommended:** Use Google Colab with free GPU for 10-100x faster training
-    - You'll need proper audio quality for good results
-    """)
+    gr.Markdown("---\n### 📚 Resources\n- [RVC Project](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI)\n- [Weights.gg](https://weights.gg/)\n\n### ⚠️ Important\n- Uses REAL RVC training\n- Models work on weights.gg\n- CPU training is VERY slow\n- Recommended: Google Colab with GPU")
 
 if __name__ == "__main__":
     demo.launch()