Update app.py

app.py

@@ -2,6 +2,7 @@
 RVC Voice Conversion – Simplified & Working Version
 Suporta: MP3, WAV, FLAC, OGG, M4A, MP4, MKV, WebM, AVI, MOV, FLV
 Gradio 6.0 Compatible
+Com aba Jobs para mostrar status
 """
 from __future__ import annotations
 
@@ -14,6 +15,7 @@ import json
 import uuid
 from datetime import datetime
 import traceback
+import threading
 
 import gradio as gr
 import numpy as np
@@ -27,9 +29,11 @@ DEVICE_LABEL = "CPU (Stable)"
 
 MODELS_DIR = Path("models")
 OUTPUTS_DIR = Path("outputs")
+JOBS_DIR = Path("conversion_jobs")
 
 MODELS_DIR.mkdir(exist_ok=True)
 OUTPUTS_DIR.mkdir(exist_ok=True)
+JOBS_DIR.mkdir(exist_ok=True)
 
 CONFIG = {
     "sample_rate": 16000,
@@ -40,6 +44,73 @@ CONFIG = {
 AUDIO_FORMATS = ["wav", "mp3", "flac", "ogg", "m4a", "aac", "wma", "mp4", "mkv", "webm", "avi", "mov", "flv"]
 VIDEO_FORMATS = ["mp4", "mkv", "webm", "avi", "mov", "flv", "m4v"]
 
+# ============================================================================
+# JOB MANAGER PARA CONVERSÃO
+# ============================================================================
+
+class ConversionJobManager:
+    def __init__(self):
+        self.jobs = {}
+        self.load_jobs()
+    
+    def load_jobs(self):
+        """Carrega jobs salvos"""
+        for job_file in JOBS_DIR.glob("*.json"):
+            try:
+                with open(job_file) as f:
+                    job = json.load(f)
+                    self.jobs[job["id"]] = job
+            except:
+                pass
+    
+    def create_job(self, job_type, filename):
+        """Cria novo job"""
+        job_id = str(uuid.uuid4())[:8]
+        job = {
+            "id": job_id,
+            "type": job_type,  # "audio" ou "video"
+            "filename": filename,
+            "status": "waiting",  # waiting, converting, done
+            "progress": 0,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            "result_files": {
+                "entrada": None,
+                "entrada_acapella": None,
+                "entrada_instrumental": None,
+                "saida_acapella": None,
+                "saida": None,
+                "video_output": None,
+                "zip": None,
+            },
+            "error": None,
+        }
+        self.jobs[job_id] = job
+        self.save_job(job_id)
+        return job_id
+    
+    def save_job(self, job_id):
+        """Salva job"""
+        job_file = JOBS_DIR / f"{job_id}.json"
+        with open(job_file, "w") as f:
+            json.dump(self.jobs[job_id], f, indent=2)
+    
+    def update_job(self, job_id, **kwargs):
+        """Atualiza job"""
+        if job_id in self.jobs:
+            self.jobs[job_id].update(kwargs)
+            self.jobs[job_id]["updated_at"] = datetime.now().isoformat()
+            self.save_job(job_id)
+    
+    def get_job(self, job_id):
+        return self.jobs.get(job_id)
+    
+    def list_jobs(self):
+        """Retorna jobs ordenados por data (mais recentes primeiro)"""
+        return sorted(self.jobs.values(), key=lambda x: x["updated_at"], reverse=True)
+
+job_manager = ConversionJobManager()
+
 # ============================================================================
 # FUNÇÕES
 # ============================================================================
@@ -102,7 +173,7 @@ def normalize_audio(audio: np.ndarray) -> np.ndarray:
     return audio
 
 def extract_audio_from_video(video_path: str) -> str:
-    """Extrai áudio de vídeo (MP4, MKV, WebM, etc)"""
+    """Extrai áudio de vídeo"""
     try:
         output_audio = Path(tempfile.gettempdir()) / f"temp_audio_{uuid.uuid4().hex[:8]}.wav"
         
@@ -139,14 +210,21 @@ def convert_voice_simple(
     pitch: int = 0,
     clean: bool = False,
     reverb: bool = False,
+    job_id: str = None,
 ) -> dict:
     """Conversão de voz SIMPLIFICADA"""
     
-    job_id = str(uuid.uuid4())[:8]
+    if job_id is None:
+        job_id = str(uuid.uuid4())[:8]
+    
     output_dir = OUTPUTS_DIR / job_id
     output_dir.mkdir(exist_ok=True)
     
     try:
+        # Atualizar status
+        if job_id:
+            job_manager.update_job(job_id, status="converting", progress=10)
+        
         # 1. Carregar áudio
         audio, sr = load_audio(audio_path)
         if audio is None:
@@ -156,6 +234,9 @@ def convert_voice_simple(
         entrada_path = output_dir / "entrada.wav"
         sf.write(entrada_path, audio, sr)
         
+        if job_id:
+            job_manager.update_job(job_id, progress=20)
+        
         # 2. Separar vocais e instrumentação
         vocals, instrumental = separate_vocals(audio, sr)
         
@@ -167,6 +248,9 @@ def convert_voice_simple(
         entrada_instrumental_path = output_dir / "entrada_instrumental.wav"
         sf.write(entrada_instrumental_path, instrumental, sr)
         
+        if job_id:
+            job_manager.update_job(job_id, progress=40)
+        
         # 3. Processar vocais
         vocals_converted = vocals.copy()
         
@@ -189,6 +273,9 @@ def convert_voice_simple(
         saida_acapella_path = output_dir / "saida_acapella.wav"
         sf.write(saida_acapella_path, vocals_converted, sr)
         
+        if job_id:
+            job_manager.update_job(job_id, progress=70)
+        
         # 4. Mixar vocal processado com instrumental original
         min_len = min(len(vocals_converted), len(instrumental))
         mix = vocals_converted[:min_len] + instrumental[:min_len]
@@ -198,6 +285,9 @@ def convert_voice_simple(
         saida_path = output_dir / "saida.wav"
         sf.write(saida_path, mix, sr)
         
+        if job_id:
+            job_manager.update_job(job_id, progress=85)
+        
         return {
             "status": "success",
             "entrada": str(entrada_path),
@@ -211,6 +301,8 @@ def convert_voice_simple(
     except Exception as e:
         print(f"Erro na conversão: {e}")
         traceback.print_exc()
+        if job_id:
+            job_manager.update_job(job_id, status="error", error=str(e))
         return {
             "status": "error",
             "error": str(e),
@@ -221,15 +313,21 @@ def process_video_simple(
     pitch: int = 0,
     clean: bool = False,
     reverb: bool = False,
+    job_id: str = None,
 ) -> dict:
     """Processamento de vídeo SIMPLIFICADO"""
     
-    job_id = str(uuid.uuid4())[:8]
+    if job_id is None:
+        job_id = str(uuid.uuid4())[:8]
+    
     output_dir = OUTPUTS_DIR / job_id
     output_dir.mkdir(exist_ok=True)
     
     try:
         # 1. Extrair áudio do vídeo
+        if job_id:
+            job_manager.update_job(job_id, status="converting", progress=5)
+        
         temp_audio = output_dir / "temp_audio.wav"
         cmd = [
             "ffmpeg", "-i", video_path, "-q:a", "0", "-map", "a",
@@ -237,12 +335,18 @@ def process_video_simple(
         ]
         subprocess.run(cmd, check=True, capture_output=True, timeout=600)
         
+        if job_id:
+            job_manager.update_job(job_id, progress=15)
+        
         # 2. Processar áudio
-        result = convert_voice_simple(str(temp_audio), pitch=pitch, clean=clean, reverb=reverb)
+        result = convert_voice_simple(str(temp_audio), pitch=pitch, clean=clean, reverb=reverb, job_id=job_id)
         
         if result["status"] != "success":
             return result
         
+        if job_id:
+            job_manager.update_job(job_id, progress=75)
+        
         # 3. Remixar vídeo com áudio novo
         output_video = output_dir / "saida_video.mp4"
         cmd = [
@@ -255,6 +359,9 @@ def process_video_simple(
         # Limpar temporário
         temp_audio.unlink(missing_ok=True)
         
+        if job_id:
+            job_manager.update_job(job_id, progress=90)
+        
         return {
             **result,
             "video_output": str(output_video),
@@ -263,6 +370,8 @@ def process_video_simple(
     except Exception as e:
         print(f"Erro no processamento de vídeo: {e}")
         traceback.print_exc()
+        if job_id:
+            job_manager.update_job(job_id, status="error", error=str(e))
         return {
             "status": "error",
             "error": str(e),
@@ -282,73 +391,125 @@ def create_zip(output_dir: Path) -> str:
         print(f"Erro ao criar ZIP: {e}")
         return None
 
-def submit_audio(audio_mic, audio_file, pitch, clean, reverb):
-    """Handler de conversão de áudio"""
+def submit_audio_async(audio_mic, audio_file, pitch, clean, reverb):
+    """Handler de conversão de áudio em thread"""
     audio_path = audio_mic or audio_file
     
     if not audio_path:
-        return "❌ Nenhum áudio fornecido", None, None, None, None, None, None
+        return "❌ Nenhum áudio fornecido"
     
-    try:
-        # Validar duração
-        duration = librosa.get_duration(filename=audio_path)
-        if duration > 600:  # 10 minutos max
-            return "❌ Áudio muito longo (máx 10 min)", None, None, None, None, None, None
-        
-        result = convert_voice_simple(audio_path, pitch=pitch, clean=clean, reverb=reverb)
-        
-        if result["status"] != "success":
-            return f"❌ Erro: {result.get('error', 'Desconhecido')}", None, None, None, None, None, None
-        
-        zip_path = create_zip(Path(result["output_dir"]))
-        
-        return (
-            f"✅ Conversão completa!",
-            result["entrada"],
-            result["entrada_acapella"],
-            result["entrada_instrumental"],
-            result["saida_acapella"],
-            result["saida"],
-            zip_path,
-        )
+    # Criar job
+    filename = Path(audio_path).name
+    job_id = job_manager.create_job("audio", filename)
     
-    except Exception as e:
-        print(f"Erro: {e}")
-        traceback.print_exc()
-        return f"❌ Erro: {str(e)}", None, None, None, None, None, None
+    # Processar em thread
+    def process():
+        try:
+            result = convert_voice_simple(audio_path, pitch=pitch, clean=clean, reverb=reverb, job_id=job_id)
+            
+            if result["status"] != "success":
+                job_manager.update_job(job_id, status="error", error=result.get("error", "Erro desconhecido"))
+                return
+            
+            zip_path = create_zip(Path(result["output_dir"]))
+            
+            job_manager.update_job(
+                job_id,
+                status="done",
+                progress=100,
+                result_files={
+                    "entrada": result["entrada"],
+                    "entrada_acapella": result["entrada_acapella"],
+                    "entrada_instrumental": result["entrada_instrumental"],
+                    "saida_acapella": result["saida_acapella"],
+                    "saida": result["saida"],
+                    "zip": zip_path,
+                }
+            )
+        except Exception as e:
+            job_manager.update_job(job_id, status="error", error=str(e))
+    
+    thread = threading.Thread(target=process, daemon=False)
+    thread.start()
+    
+    return f"✅ Conversão iniciada! Job ID: {job_id}\n\nVá para a aba 'Jobs' para acompanhar."
 
-def submit_video(video_file, pitch, clean, reverb):
-    """Handler de conversão de vídeo"""
+def submit_video_async(video_file, pitch, clean, reverb):
+    """Handler de conversão de vídeo em thread"""
     
     if not video_file:
-        return "❌ Nenhum vídeo fornecido", None, None, None, None, None, None, None
+        return "❌ Nenhum vídeo fornecido"
     
-    try:
-        result = process_video_simple(video_file, pitch=pitch, clean=clean, reverb=reverb)
-        
-        if result["status"] != "success":
-            return f"❌ Erro: {result.get('error', 'Desconhecido')}", None, None, None, None, None, None, None
-        
-        zip_path = create_zip(Path(result["output_dir"]))
-        
-        return (
-            f"✅ Conversão de vídeo completa!",
-            result["entrada"],
-            result["entrada_acapella"],
-            result["entrada_instrumental"],
-            result["saida_acapella"],
-            result["saida"],
-            result["video_output"],
-            zip_path,
-        )
+    # Criar job
+    filename = Path(video_file).name
+    job_id = job_manager.create_job("video", filename)
     
-    except Exception as e:
-        print(f"Erro: {e}")
-        traceback.print_exc()
-        return f"❌ Erro: {str(e)}", None, None, None, None, None, None, None
+    # Processar em thread
+    def process():
+        try:
+            result = process_video_simple(video_file, pitch=pitch, clean=clean, reverb=reverb, job_id=job_id)
+            
+            if result["status"] != "success":
+                job_manager.update_job(job_id, status="error", error=result.get("error", "Erro desconhecido"))
+                return
+            
+            zip_path = create_zip(Path(result["output_dir"]))
+            
+            job_manager.update_job(
+                job_id,
+                status="done",
+                progress=100,
+                result_files={
+                    "entrada": result["entrada"],
+                    "entrada_acapella": result["entrada_acapella"],
+                    "entrada_instrumental": result["entrada_instrumental"],
+                    "saida_acapella": result["saida_acapella"],
+                    "saida": result["saida"],
+                    "video_output": result.get("video_output"),
+                    "zip": zip_path,
+                }
+            )
+        except Exception as e:
+            job_manager.update_job(job_id, status="error", error=str(e))
+    
+    thread = threading.Thread(target=process, daemon=False)
+    thread.start()
+    
+    return f"✅ Conversão de vídeo iniciada! Job ID: {job_id}\n\nVá para a aba 'Jobs' para acompanhar."
+
+def refresh_jobs():
+    """Retorna lista de jobs com status"""
+    job_manager.load_jobs()
+    jobs = job_manager.list_jobs()
+    
+    if not jobs:
+        return "Nenhuma conversão realizada ainda."
+    
+    output = ""
+    for job in jobs:
+        status_icon = {
+            "waiting": "⏳ Esperando",
+            "converting": "🔄 Convertendo",
+            "done": "✅ Concluído",
+            "error": "❌ Erro",
+        }.get(job["status"], "❓")
+        
+        output += f"**{status_icon}** - {job['filename']} (ID: `{job['id']}`)\n"
+        output += f"- Tipo: {job['type'].upper()}\n"
+        output += f"- Progresso: {job['progress']}%\n"
+        output += f"- Criado: {job['created_at']}\n"
+        
+        if job["status"] == "done":
+            output += f"- 📦 ZIP: Disponível para download\n"
+        elif job["status"] == "error":
+            output += f"- Erro: {job['error']}\n"
+        
+        output += "\n"
+    
+    return output
 
 # ============================================================================
-# INTERFACE GRADIO (GRADIO 6.0 COMPATIBLE)
+# GRADIO UI (GRADIO 6.0 COMPATIBLE)
 # ============================================================================
 
 with gr.Blocks(title="RVC Voice Conversion") as demo:
@@ -381,22 +542,10 @@ with gr.Blocks(title="RVC Voice Conversion") as demo:
                     reverb = gr.Checkbox(value=False, label="Reverb")
                     
                     convert_btn = gr.Button("🚀 Converter Áudio", variant="primary", size="lg")
-                
-                with gr.Column(scale=1):
-                    status_audio = gr.Textbox(label="Status", interactive=False)
-                    
-                    gr.Markdown("### 📦 Outputs (5 Áudios)")
-                    entrada_aud = gr.Audio(label="entrada.wav", interactive=False)
-                    entrada_acap = gr.Audio(label="entrada_acapella.wav", interactive=False)
-                    entrada_inst = gr.Audio(label="entrada_instrumental.wav", interactive=False)
-                    saida_acap = gr.Audio(label="saida_acapella.wav", interactive=False)
-                    saida_aud = gr.Audio(label="saida.wav", interactive=False)
-                    
-                    gr.Markdown("### 📥 Download")
-                    audio_zip = gr.File(label="Baixar ZIP", interactive=False)
+                    status_output = gr.Textbox(label="Status", interactive=False)
         
-        # ── TAB 2: VIDEO ──────────────────────────────────────────
-        with gr.Tab("🎬 Converter Vídeo (MP4, MKV, WebM...)"):
+        # ─��� TAB 2: VIDEO ──────────────────────────────────────────
+        with gr.Tab("🎬 Converter Vídeo"):
             
             with gr.Row():
                 with gr.Column(scale=1):
@@ -410,39 +559,92 @@ with gr.Blocks(title="RVC Voice Conversion") as demo:
                     video_reverb = gr.Checkbox(value=False, label="Reverb")
                     
                     video_btn = gr.Button("🎬 Converter Vídeo", variant="primary", size="lg")
+                    video_status_output = gr.Textbox(label="Status", interactive=False)
+        
+        # ── TAB 3: JOBS ──────────────────────────────────────────
+        with gr.Tab("📋 JOBS"):
+            gr.Markdown("### 📊 Status de Conversões")
+            gr.Markdown("Clique em **Refresh** ou espere auto-atualizar")
+            
+            refresh_btn = gr.Button("🔄 Refresh", size="lg", variant="primary")
+            jobs_output = gr.Markdown()
+            
+            refresh_btn.click(refresh_jobs, outputs=jobs_output)
+            demo.load(refresh_jobs, outputs=jobs_output)
+            
+            # Auto-atualizar a cada 3 segundos
+            demo.load(
+                lambda: (refresh_jobs(),),
+                outputs=[jobs_output],
+                every=3
+            )
+            
+            gr.Markdown("### ⬇️ Clique na setinha para expandir e ver os 5 áudios")
+            
+            with gr.Accordion("📦 Resultados (Clique para expandir ⬇️)"):
+                job_id_input = gr.Textbox(label="🔑 Cole o Job ID aqui para ver os resultados", placeholder="Ex: a1b2c3d4")
+                show_results_btn = gr.Button("Mostrar Resultados", variant="primary")
                 
-                with gr.Column(scale=1):
-                    status_video = gr.Textbox(label="Status", interactive=False)
-                    
-                    gr.Markdown("### 📦 Outputs (5 Áudios)")
-                    v_entrada_aud = gr.Audio(label="entrada.wav", interactive=False)
-                    v_entrada_acap = gr.Audio(label="entrada_acapella.wav", interactive=False)
-                    v_entrada_inst = gr.Audio(label="entrada_instrumental.wav", interactive=False)
-                    v_saida_acap = gr.Audio(label="saida_acapella.wav", interactive=False)
-                    v_saida_aud = gr.Audio(label="saida.wav", interactive=False)
-                    
-                    gr.Markdown("### 🎬 Vídeo")
+                with gr.Group():
+                    gr.Markdown("### 🎵 Áudios de Entrada")
+                    entrada_aud = gr.Audio(label="entrada.wav", interactive=False)
+                    entrada_acap = gr.Audio(label="entrada_acapella.wav", interactive=False)
+                    entrada_inst = gr.Audio(label="entrada_instrumental.wav", interactive=False)
+                
+                with gr.Group():
+                    gr.Markdown("### 🎵 Áudios de Saída")
+                    saida_acap = gr.Audio(label="saida_acapella.wav", interactive=False)
+                    saida_aud = gr.Audio(label="saida.wav", interactive=False)
+                
+                with gr.Group():
+                    gr.Markdown("### 🎬 Vídeo de Saída")
                     video_output = gr.Video(label="saida_video.mp4", interactive=False)
-                    
+                
+                with gr.Group():
                     gr.Markdown("### 📥 Download")
-                    video_zip = gr.File(label="Baixar ZIP", interactive=False)
+                    download_file = gr.File(label="Baixar ZIP com todos os arquivos")
+                
+                def show_job_results(job_id_str):
+                    if not job_id_str or not job_id_str.strip():
+                        return None, None, None, None, None, None, None
+                    
+                    job = job_manager.get_job(job_id_str.strip())
+                    if not job or job["status"] != "done":
+                        return None, None, None, None, None, None, None
+                    
+                    files = job["result_files"]
+                    return (
+                        files["entrada"],
+                        files["entrada_acapella"],
+                        files["entrada_instrumental"],
+                        files["saida_acapella"],
+                        files["saida"],
+                        files.get("video_output"),
+                        files["zip"],
+                    )
+                
+                show_results_btn.click(
+                    show_job_results,
+                    inputs=job_id_input,
+                    outputs=[entrada_aud, entrada_acap, entrada_inst, saida_acap, saida_aud, video_output, download_file]
+                )
     
     # Wire eventos
     convert_btn.click(
-        fn=submit_audio,
+        submit_audio_async,
         inputs=[audio_mic, audio_file, pitch, clean, reverb],
-        outputs=[status_audio, entrada_aud, entrada_acap, entrada_inst, saida_acap, saida_aud, audio_zip],
+        outputs=status_output,
     )
     
     video_btn.click(
-        fn=submit_video,
+        submit_video_async,
         inputs=[video_file, video_pitch, video_clean, video_reverb],
-        outputs=[status_video, v_entrada_aud, v_entrada_acap, v_entrada_inst, v_saida_acap, v_saida_aud, video_output, video_zip],
+        outputs=video_status_output,
     )
 
 if __name__ == "__main__":
     demo.launch(
-        share=True,  # ✅ IMPORTANTE: share=True para Hugging Face Spaces
+        share=True,
         server_name="0.0.0.0",
         server_port=7860,
         show_error=True