Update app.py

app.py

@@ -89,13 +89,16 @@ corretor_disponivel = False
 
 def get_system_info():
     """Retorna informações do sistema"""
-    if torch.cuda.is_available():
-        gpu_name = torch.cuda.get_device_name(0)
-        gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
-        return f"{gpu_name} ({gpu_memory:.1f}GB)"
-    else:
-        ram = psutil.virtual_memory().total / 1024**3
-        return f"CPU ({ram:.1f}GB RAM)"
+    try:
+        if torch.cuda.is_available():
+            gpu_name = torch.cuda.get_device_name(0)
+            gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+            return f"{gpu_name} ({gpu_memory:.1f}GB)"
+        else:
+            ram = psutil.virtual_memory().total / 1024**3
+            return f"CPU ({ram:.1f}GB RAM)"
+    except:
+        return "Sistema não identificado"
 
 def inicializar_modelos(modelo_selecionado, progress=gr.Progress()):
     """Inicializa os modelos necessários"""
@@ -108,30 +111,43 @@ def inicializar_modelos(modelo_selecionado, progress=gr.Progress()):
         
         # Carregar WhisperX se não estiver em cache
         if modelo_selecionado not in whisper_models:
-            whisper_models[modelo_selecionado] = whisperx.load_model(
-                modelo_selecionado, 
-                device, 
-                compute_type=compute_type, 
-                language=LANGUAGE,
-                asr_options={
-                    "beam_size": config["beam_size"],
-                    "best_of": config["best_of"],
-                    "temperature": config["temperature"],
-                    "condition_on_previous_text": True,
-                    "word_timestamps": True,
-                    "prepend_punctuations": "\"'"¿([{-",
-                    "append_punctuations": "\"'.。,，!！?？:：")]}、",
-                    "vad_filter": True,
-                    "vad_parameters": dict(min_silence_duration_ms=500)
-                }
-            )
+            try:
+                whisper_models[modelo_selecionado] = whisperx.load_model(
+                    modelo_selecionado, 
+                    device, 
+                    compute_type=compute_type, 
+                    language=LANGUAGE,
+                    asr_options={
+                        "beam_size": config["beam_size"],
+                        "best_of": config["best_of"],
+                        "temperature": config["temperature"],
+                        "condition_on_previous_text": True,
+                        "word_timestamps": True,
+                        "prepend_punctuations": "\"'([{-",
+                        "append_punctuations": "\"'.,:!?)]}-",
+                        "vad_filter": True,
+                        "vad_parameters": dict(min_silence_duration_ms=500)
+                    }
+                )
+            except Exception as model_error:
+                # Fallback sem opções avançadas se der erro
+                whisper_models[modelo_selecionado] = whisperx.load_model(
+                    modelo_selecionado, 
+                    device, 
+                    compute_type=compute_type, 
+                    language=LANGUAGE
+                )
         
         progress(0.3, desc="🎯 Carregando alinhamento temporal...")
         if align_model is None:
-            align_model, metadata = whisperx.load_align_model(
-                language_code=LANGUAGE, 
-                device=device
-            )
+            try:
+                align_model, metadata = whisperx.load_align_model(
+                    language_code=LANGUAGE, 
+                    device=device
+                )
+            except Exception as align_error:
+                print(f"Erro no alinhamento: {align_error}")
+                return f"❌ Erro ao carregar modelo de alinhamento: {str(align_error)}"
         
         progress(0.5, desc="📝 Carregando corretor PTT5...")
         if not corretor_disponivel:
@@ -227,16 +243,29 @@ def processar_audio(audio_file, modelo_selecionado, progress=gr.Progress()):
         progress(0.6, desc="🎯 Alinhamento temporal de precisão...")
         
         # Alinhamento com configurações para VSL
-        aligned = whisperx.align(
-            result["segments"], 
-            align_model, 
-            metadata, 
-            audio, 
-            device,
-            return_char_alignments=False,
-            interpolate_method="linear",
-            extend_duration=0.1
-        )
+        try:
+            aligned = whisperx.align(
+                result["segments"], 
+                align_model, 
+                metadata, 
+                audio, 
+                device,
+                return_char_alignments=False,
+                interpolate_method="linear"
+            )
+        except Exception as align_error:
+            print(f"Erro no alinhamento: {align_error}")
+            # Fallback: usar segmentos originais sem alinhamento fino
+            aligned = {"word_segments": []}
+            for segment in result.get("segments", []):
+                if "words" in segment:
+                    for word in segment["words"]:
+                        aligned["word_segments"].append({
+                            "word": word.get("word", ""),
+                            "start": word.get("start", 0),
+                            "end": word.get("end", 0),
+                            "score": word.get("probability", 0.5)
+                        })
         
         progress(0.8, desc="📝 Aplicando correções para VSL...")
         
@@ -458,7 +487,10 @@ def criar_interface():
                 )
                 
                 # Sistema info
-                system_info_display = gr.Markdown(f"🖥️ **Sistema:** {get_system_info()}")
+                try:
+                    system_info_display = gr.Markdown(f"🖥️ **Sistema:** {get_system_info()}")
+                except:
+                    system_info_display = gr.Markdown("🖥️ **Sistema:** Carregando...")
         
         # Atualizar info do modelo
         def atualizar_info_modelo(modelo):
@@ -527,16 +559,27 @@ def criar_interface():
 
 # === EXECUÇÃO ===
 if __name__ == "__main__":
-    print("🎤 Transcritor VSL Pro - WhisperX")
-    print(f"🖥️  Sistema: {get_system_info()}")
-    print("🎯 Otimizado para VSL de até 15 minutos")
-    
-    demo = criar_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        quiet=False,
-        show_tips=True
-    )
+    try:
+        print("🎤 Transcritor VSL Pro - WhisperX")
+        print(f"🖥️  Sistema: {get_system_info()}")
+        print("🎯 Otimizado para VSL de até 15 minutos")
+        
+        demo = criar_interface()
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True,
+            quiet=False,
+            show_tips=True
+        )
+    except Exception as e:
+        print(f"Erro na inicialização: {e}")
+        # Fallback simples
+        demo = gr.Interface(
+            fn=lambda x: "Sistema em manutenção",
+            inputs=gr.Audio(),
+            outputs=gr.Textbox(),
+            title="🎤 Transcritor VSL Pro"
+        )
+        demo.launch()