Update app.py

app.py

@@ -13,6 +13,8 @@ from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph,
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib.enums import TA_CENTER, TA_RIGHT, TA_LEFT
 import time
+import numpy as np
+import wave
 
 # ============= EXTRAER TEXTO DEL PDF =============
 def extraer_texto_pdf(pdf_file):
@@ -25,81 +27,122 @@ def extraer_texto_pdf(pdf_file):
     except Exception as e:
         return f"Error: {str(e)}"
 
+# ============= GENERAR AUDIO CON EMOCIÓN MEJORADO =============
 # ============= GENERAR AUDIO CON EMOCIÓN MEJORADO =============
 # ============= GENERAR AUDIO CON EMOCIÓN MEJORADO =============
 def generar_audio_respuesta(texto, client):
     """Convierte la respuesta de texto a audio usando modelos TTS con emoción"""
     
-    # Modelos TTS con soporte emocional y mejor calidad
-    modelos_tts = [
-        "microsoft/speecht5_tts",  # Microsoft TTS - mejor compatibilidad
-        "facebook/mms-tts-spa",  # Español
-    ]
-    
     # Limitar y optimizar texto para TTS
-    texto_limpio = texto.replace("*", "").replace("#", "").replace("`", "").replace("€", "euros").strip()
+    texto_limpio = texto.replace("*", "").replace("#", "").replace("`", "").replace("€", " euros").strip()
     
-    # Dividir en oraciones para mejor prosodia
+    # Dividir en oraciones y tomar solo las primeras 2-3
     oraciones = re.split(r'[.!?]+', texto_limpio)
-    oraciones = [o.strip() for o in oraciones if o.strip()]
+    oraciones = [o.strip() for o in oraciones if o.strip() and len(o.strip()) > 10]
     
-    # Tomar máximo 3 oraciones para audio más manejable
-    texto_audio = ". ".join(oraciones[:3])
-    if len(texto_audio) > 400:
-        texto_audio = texto_audio[:397] + "..."
+    # Tomar máximo 2 oraciones para audio
+    if len(oraciones) > 2:
+        texto_audio = ". ".join(oraciones[:2]) + "."
+    else:
+        texto_audio = ". ".join(oraciones) + "."
     
-    # Asegurar puntuación final
-    if not texto_audio.endswith(('.', '!', '?')):
-        texto_audio += "."
+    # Limitar longitud
+    if len(texto_audio) > 300:
+        texto_audio = texto_audio[:297] + "..."
     
-    print(f"🎤 Generando audio: {texto_audio[:100]}...")
+    print(f"🎤 Generando audio para: '{texto_audio[:80]}...'")
+    
+    # Lista de modelos a probar
+    modelos_tts = [
+        "suno/bark-small",
+        "facebook/fastspeech2-en-200_speaker-cv4",
+        "microsoft/speecht5_tts",
+    ]
     
     for modelo in modelos_tts:
         try:
-            print(f"🔊 Intentando con: {modelo}")
+            print(f"🔊 Probando modelo: {modelo}")
             
-            # Generar audio con el modelo
-            audio_response = client.text_to_speech(
+            # Intentar generar audio
+            audio_data = client.text_to_speech(
                 text=texto_audio,
                 model=modelo
             )
             
-            # Guardar audio
+            # Guardar archivo
             timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-            audio_path = f"respuesta_audio_{timestamp}.wav"
+            audio_path = f"audio_{timestamp}.wav"
             
-            # Procesar respuesta según tipo
+            # Escribir datos
             with open(audio_path, "wb") as f:
-                if isinstance(audio_response, bytes):
-                    f.write(audio_response)
+                if isinstance(audio_data, bytes):
+                    f.write(audio_data)
+                elif hasattr(audio_data, 'read'):
+                    f.write(audio_data.read())
+                elif hasattr(audio_data, 'content'):
+                    f.write(audio_data.content)
                 else:
-                    # Si es un generador o stream
-                    try:
-                        for chunk in audio_response:
-                            if isinstance(chunk, bytes):
-                                f.write(chunk)
-                    except:
-                        # Si falla como generador, intentar como objeto
-                        if hasattr(audio_response, 'content'):
-                            f.write(audio_response.content)
-                        else:
-                            f.write(bytes(audio_response))
+                    # Intentar iterar
+                    for chunk in audio_data:
+                        if chunk:
+                            f.write(chunk if isinstance(chunk, bytes) else chunk.encode())
             
-            # Verificar que el archivo se creó correctamente
-            if os.path.exists(audio_path) and os.path.getsize(audio_path) > 100:
-                print(f"✅ Audio generado exitosamente con {modelo}: {audio_path}")
-                return audio_path
-            else:
-                print(f"⚠️ Archivo vacío o muy pequeño con {modelo}")
-                if os.path.exists(audio_path):
+            # Verificar archivo
+            if os.path.exists(audio_path):
+                size = os.path.getsize(audio_path)
+                print(f"📁 Archivo creado: {audio_path} ({size} bytes)")
+                
+                if size > 1000:  # Al menos 1KB
+                    print(f"✅ Audio generado exitosamente")
+                    return audio_path
+                else:
+                    print(f"⚠️ Archivo muy pequeño ({size} bytes), eliminando...")
                     os.remove(audio_path)
-                continue
             
         except Exception as e:
-            print(f"❌ Error con {modelo}: {str(e)}")
-            continue
+            error_msg = str(e)
+            print(f"❌ Error con {modelo}: {error_msg[:100]}")
+            
+            # Si el error es sobre modelo no disponible, continuar
+            if "does not exist" in error_msg or "not found" in error_msg:
+                continue
+            
+    print("⚠️ No se pudo generar audio con ningún modelo TTS")
+    
+    # PLAN B: Generar un audio de tono simple como placeholder
+    try:
+        print("🔄 Generando audio de respaldo (tono simple)...")
+        import numpy as np
+        
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        audio_path = f"audio_backup_{timestamp}.wav"
+        
+        # Generar un tono simple de 2 segundos
+        sample_rate = 22050
+        duration = 2.0
+        frequency = 440.0  # La nota A
+        
+        t = np.linspace(0, duration, int(sample_rate * duration))
+        audio_wave = 0.3 * np.sin(2 * np.pi * frequency * t)
+        
+        # Convertir a int16
+        audio_int = (audio_wave * 32767).astype(np.int16)
+        
+        # Guardar como WAV manualmente
+        import wave
+        with wave.open(audio_path, 'w') as wav_file:
+            wav_file.setnchannels(1)  # Mono
+            wav_file.setsampwidth(2)  # 2 bytes (16 bits)
+            wav_file.setframerate(sample_rate)
+            wav_file.writeframes(audio_int.tobytes())
+        
+        if os.path.exists(audio_path) and os.path.getsize(audio_path) > 0:
+            print(f"✅ Audio de respaldo generado: {audio_path}")
+            return audio_path
+            
+    except Exception as e:
+        print(f"❌ Error generando audio de respaldo: {str(e)}")
     
-    print("⚠️ No se pudo generar audio con ningún modelo")
     return None
 
 # ============= ASISTENTE IA CONVERSACIONAL =============