Update app.py

app.py

@@ -88,24 +88,26 @@ Responde ahora:"""
     
     return "❌ No se pudo obtener respuesta del asistente IA", None
 
-# ============= GENERAR AUDIO DE LA RESPUESTA CON AVATAR ROBÓTICO =============
+# ============= GENERAR AUDIO DE LA RESPUESTA CON MODELO MEJORADO =============
 def generar_audio_respuesta(texto, client):
     """Convierte la respuesta de texto a audio usando TTS avanzado"""
     
     modelos_tts = [
         "facebook/mms-tts-spa",
         "microsoft/speecht5_tts",
-        "facebook/fastspeech2-en-ljspeech"
+        "suno/bark",
+        "facebook/fastspeech2-en-200_speaker-cv4",
     ]
     
     # Limitar texto para TTS
-    texto_corto = texto[:500] if len(texto) > 500 else texto
+    texto_corto = texto[:400] if len(texto) > 400 else texto
     
     for modelo in modelos_tts:
         try:
             print(f"🔊 Generando audio con: {modelo}")
             
-            audio = client.text_to_speech(
+            # Intentar generar audio
+            audio_bytes = client.text_to_speech(
                 text=texto_corto,
                 model=modelo
             )
@@ -115,15 +117,21 @@ def generar_audio_respuesta(texto, client):
             audio_path = f"respuesta_audio_{timestamp}.wav"
             
             with open(audio_path, "wb") as f:
-                f.write(audio)
+                if isinstance(audio_bytes, bytes):
+                    f.write(audio_bytes)
+                else:
+                    # Si es un generador, escribir el contenido
+                    for chunk in audio_bytes:
+                        f.write(chunk)
             
-            print(f"✅ Audio generado: {audio_path}")
+            print(f"✅ Audio generado exitosamente: {audio_path}")
             return audio_path
-        
+            
         except Exception as e:
-            print(f"❌ Error generando audio con {modelo}: {str(e)}")
+            print(f"❌ Error con {modelo}: {str(e)}")
             continue
     
+    print("⚠️ No se pudo generar audio con ningún modelo")
     return None
 
 # ============= ANÁLISIS DE SENTIMIENTO DE FACTURA =============
@@ -369,7 +377,265 @@ Formato profesional y conciso:"""
     except:
         return "No se pudo generar el resumen ejecutivo"
 
-# ============= EXTRACTOR DE GASTOS DEDUCIBLES =============
+# ============= ANÁLISIS DE DUPLICADOS =============
+def detectar_facturas_duplicadas(datos_json, client):
+    """Analiza si esta factura puede ser un duplicado"""
+    
+    prompt = f"""Analiza esta factura y determina indicadores de duplicación:
+
+DATOS: {json.dumps(datos_json, indent=2)}
+
+Busca:
+- Patrones de números de factura sospechosos
+- Fechas anómalas
+- Importes repetitivos
+
+Responde en JSON:
+{{
+  "posible_duplicado": true/false,
+  "nivel_confianza": "bajo/medio/alto",
+  "indicadores": ["indicador1", "indicador2"],
+  "recomendacion": "texto"
+}}"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=300,
+            temperature=0.2
+        )
+        
+        resultado = response.choices[0].message.content
+        resultado = re.sub(r'```json\s*', '', resultado)
+        resultado = re.sub(r'```\s*', '', resultado).strip()
+        
+        match = re.search(r'\{.*\}', resultado, re.DOTALL)
+        if match:
+            return json.loads(match.group(0))
+    except:
+        pass
+    
+    return {"posible_duplicado": False, "nivel_confianza": "bajo", "indicadores": [], "recomendacion": "No se detectaron patrones duplicados"}
+
+# ============= CALCULADORA DE IMPACTO PRESUPUESTARIO =============
+def calcular_impacto_presupuesto(datos_json, client):
+    """Calcula el impacto de esta factura en un presupuesto mensual promedio"""
+    
+    total = datos_json.get('totales', {}).get('total', datos_json.get('total', 0))
+    
+    prompt = f"""Analiza el impacto presupuestario de esta factura:
+
+Total: {total}€
+Datos: {json.dumps(datos_json, indent=2)}
+
+Calcula:
+- Porcentaje sobre presupuesto promedio PYME (10.000€/mes)
+- Nivel de impacto
+- Recomendaciones de planificación
+
+Responde en JSON:
+{{
+  "impacto_porcentaje": number,
+  "nivel_impacto": "bajo/medio/alto/crítico",
+  "analisis": "texto",
+  "recomendacion_financiera": "texto"
+}}"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=400,
+            temperature=0.3
+        )
+        
+        resultado = response.choices[0].message.content
+        resultado = re.sub(r'```json\s*', '', resultado)
+        resultado = re.sub(r'```\s*', '', resultado).strip()
+        
+        match = re.search(r'\{.*\}', resultado, re.DOTALL)
+        if match:
+            return json.loads(match.group(0))
+    except:
+        pass
+    
+    return {"impacto_porcentaje": 0, "nivel_impacto": "bajo", "analisis": "No disponible", "recomendacion_financiera": "Consulte con su contador"}
+
+# ============= GENERADOR DE RECORDATORIOS =============
+def generar_recordatorios_pago(datos_json, client):
+    """Genera recordatorios inteligentes de pago"""
+    
+    prompt = f"""Basándote en esta factura, genera un plan de recordatorios de pago:
+
+DATOS: {json.dumps(datos_json, indent=2)}
+
+Crea:
+- 3 recordatorios (inicial, intermedio, urgente)
+- Fechas sugeridas
+- Mensajes personalizados
+
+Responde en JSON:
+{{
+  "recordatorios": [
+    {{"tipo": "inicial", "dias_antes": number, "mensaje": "texto"}},
+    {{"tipo": "intermedio", "dias_antes": number, "mensaje": "texto"}},
+    {{"tipo": "urgente", "dias_antes": number, "mensaje": "texto"}}
+  ]
+}}"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=500,
+            temperature=0.4
+        )
+        
+        resultado = response.choices[0].message.content
+        resultado = re.sub(r'```json\s*', '', resultado)
+        resultado = re.sub(r'```\s*', '', resultado).strip()
+        
+        match = re.search(r'\{.*\}', resultado, re.DOTALL)
+        if match:
+            return json.loads(match.group(0))
+    except:
+        pass
+    
+    return {"recordatorios": []}
+
+# ============= ANÁLISIS DE CONDICIONES DE PAGO =============
+def analizar_condiciones_pago(datos_json, texto, client):
+    """Analiza las condiciones de pago y sugiere negociaciones"""
+    
+    prompt = f"""Analiza las condiciones de pago de esta factura:
+
+DATOS: {json.dumps(datos_json, indent=2)}
+TEXTO: {texto[:2000]}
+
+Identifica:
+- Plazo de pago actual
+- Condiciones especiales
+- Oportunidades de negociación
+- Descuentos por pronto pago
+
+Responde en JSON:
+{{
+  "plazo_actual": "texto",
+  "condiciones_especiales": ["condicion1", "condicion2"],
+  "oportunidades_negociacion": "texto",
+  "sugerencias_mejora": "texto"
+}}"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=400,
+            temperature=0.3
+        )
+        
+        resultado = response.choices[0].message.content
+        resultado = re.sub(r'```json\s*', '', resultado)
+        resultado = re.sub(r'```\s*', '', resultado).strip()
+        
+        match = re.search(r'\{.*\}', resultado, re.DOTALL)
+        if match:
+            return json.loads(match.group(0))
+    except:
+        pass
+    
+    return {"plazo_actual": "N/A", "condiciones_especiales": [], "oportunidades_negociacion": "No detectadas", "sugerencias_mejora": "Revisar manualmente"}
+
+# ============= COMPARADOR CON MERCADO =============
+def comparar_precios_mercado(datos_json, client):
+    """Compara los precios de la factura con precios de mercado promedio"""
+    
+    productos = datos_json.get('productos', [])
+    if not productos:
+        return {"analisis": "No hay productos para comparar"}
+    
+    productos_texto = "\n".join([f"- {p.get('descripcion', 'N/A')}: {p.get('precio_unitario', 0)}€" for p in productos[:5]])
+    
+    prompt = f"""Analiza si estos precios son razonables comparados con el mercado:
+
+PRODUCTOS Y PRECIOS:
+{productos_texto}
+
+Determina:
+- ¿Los precios son competitivos?
+- ¿Hay precios excesivamente altos?
+- Recomendaciones
+
+Responde en JSON:
+{{
+  "evaluacion_general": "competitivo/normal/elevado",
+  "productos_caros": ["producto1", "producto2"],
+  "ahorro_potencial": number,
+  "recomendacion": "texto"
+}}"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=400,
+            temperature=0.3
+        )
+        
+        resultado = response.choices[0].message.content
+        resultado = re.sub(r'```json\s*', '', resultado)
+        resultado = re.sub(r'```\s*', '', resultado).strip()
+        
+        match = re.search(r'\{.*\}', resultado, re.DOTALL)
+        if match:
+            return json.loads(match.group(0))
+    except:
+        pass
+    
+    return {"evaluacion_general": "normal", "productos_caros": [], "ahorro_potencial": 0, "recomendacion": "Precios dentro del rango esperado"}
+
+# ============= VALIDADOR DE DATOS FISCALES =============
+def validar_datos_fiscales(datos_json, client):
+    """Valida que los datos fiscales sean correctos y completos"""
+    
+    prompt = f"""Valida los datos fiscales de esta factura:
+
+DATOS: {json.dumps(datos_json, indent=2)}
+
+Verifica:
+- NIF/CIF válido (formato español)
+- IVA correcto (21%, 10%, 4%)
+- Datos obligatorios presentes
+- Formato de factura legal
+
+Responde en JSON:
+{{
+  "es_valida": true/false,
+  "errores": ["error1", "error2"],
+  "advertencias": ["advertencia1"],
+  "nivel_cumplimiento": "completo/parcial/insuficiente"
+}}"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=400,
+            temperature=0.2
+        )
+        
+        resultado = response.choices[0].message.content
+        resultado = re.sub(r'```json\s*', '', resultado)
+        resultado = re.sub(r'```\s*', '', resultado).strip()
+        
+        match = re.search(r'\{.*\}', resultado, re.DOTALL)
+        if match:
+            return json.loads(match.group(0))
+    except:
+        pass
+    
+    return {"es_valida": True, "errores": [], "advertencias": [], "nivel_cumplimiento": "completo"}
 def extraer_gastos_deducibles(datos_json, texto, client):
     """Identifica qué parte de la factura es deducible fiscalmente"""
     
@@ -629,20 +895,105 @@ def json_a_csv(datos_json):
     
     return pd.DataFrame(filas)
 
-# ============= GENERAR CSV DE TRADUCCIÓN =============
-def traduccion_a_csv(traduccion_texto, idioma):
-    """Convierte el texto traducido en un CSV"""
+# ============= GENERAR CSV TABULAR DE TRADUCCIÓN =============
+def traduccion_a_csv(datos_json, traduccion_texto, idioma):
+    """Convierte la factura traducida en un CSV tabular estructurado"""
+    
+    if not datos_json:
+        return None
     
     timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
     csv_filename = f"factura_traducida_{idioma}_{timestamp}.csv"
     
-    # Crear DataFrame simple con la traducción
-    df = pd.DataFrame({
-        'Idioma': [idioma],
-        'Contenido': [traduccion_texto],
-        'Fecha': [datetime.now().strftime('%Y-%m-%d %H:%M:%S')]
-    })
+    filas = []
+    
+    # Intentar traducir cada campo
+    token = os.getenv("aa")
+    if token:
+        client = InferenceClient(token=token)
+        
+        # Traducir secciones
+        try:
+            # Información general
+            filas.append({
+                'Sección': 'INFORMACIÓN GENERAL' if idioma == 'Español' else 'GENERAL INFORMATION',
+                'Campo': 'Número de Factura' if idioma == 'Español' else 'Invoice Number',
+                'Valor': datos_json.get('numero_factura', 'N/A'),
+                'Tipo': 'Identificador' if idioma == 'Español' else 'Identifier'
+            })
+            filas.append({
+                'Sección': 'INFORMACIÓN GENERAL' if idioma == 'Español' else 'GENERAL INFORMATION',
+                'Campo': 'Fecha' if idioma == 'Español' else 'Date',
+                'Valor': datos_json.get('fecha', 'N/A'),
+                'Tipo': 'Fecha' if idioma == 'Español' else 'Date'
+            })
+            
+            # Emisor
+            if 'emisor' in datos_json:
+                emisor = datos_json['emisor']
+                if isinstance(emisor, dict):
+                    for key, value in emisor.items():
+                        filas.append({
+                            'Sección': 'EMISOR' if idioma == 'Español' else 'ISSUER',
+                            'Campo': key.replace('_', ' ').title(),
+                            'Valor': str(value),
+                            'Tipo': 'Información' if idioma == 'Español' else 'Information'
+                        })
+            
+            # Cliente
+            if 'cliente' in datos_json:
+                cliente = datos_json['cliente']
+                if isinstance(cliente, dict):
+                    for key, value in cliente.items():
+                        filas.append({
+                            'Sección': 'CLIENTE' if idioma == 'Español' else 'CLIENT',
+                            'Campo': key.replace('_', ' ').title(),
+                            'Valor': str(value),
+                            'Tipo': 'Información' if idioma == 'Español' else 'Information'
+                        })
+            
+            # Productos
+            productos = datos_json.get('productos', [])
+            if productos:
+                for i, prod in enumerate(productos, 1):
+                    filas.append({
+                        'Sección': 'PRODUCTOS' if idioma == 'Español' else 'PRODUCTS',
+                        'Campo': f'Producto {i}' if idioma == 'Español' else f'Product {i}',
+                        'Valor': prod.get('descripcion', 'N/A'),
+                        'Tipo': 'Descripción' if idioma == 'Español' else 'Description'
+                    })
+                    filas.append({
+                        'Sección': 'PRODUCTOS' if idioma == 'Español' else 'PRODUCTS',
+                        'Campo': f'Cantidad P{i}' if idioma == 'Español' else f'Quantity P{i}',
+                        'Valor': str(prod.get('cantidad', '')),
+                        'Tipo': 'Numérico' if idioma == 'Español' else 'Numeric'
+                    })
+            
+            # Totales
+            totales = datos_json.get('totales', {})
+            if totales:
+                filas.append({
+                    'Sección': 'TOTALES' if idioma == 'Español' else 'TOTALS',
+                    'Campo': 'Base Imponible' if idioma == 'Español' else 'Taxable Base',
+                    'Valor': str(totales.get('base_imponible', 0)),
+                    'Tipo': 'Monetario' if idioma == 'Español' else 'Monetary'
+                })
+                filas.append({
+                    'Sección': 'TOTALES' if idioma == 'Español' else 'TOTALS',
+                    'Campo': 'IVA' if idioma == 'Español' else 'VAT',
+                    'Valor': str(totales.get('iva', 0)),
+                    'Tipo': 'Monetario' if idioma == 'Español' else 'Monetary'
+                })
+                filas.append({
+                    'Sección': 'TOTALES' if idioma == 'Español' else 'TOTALS',
+                    'Campo': 'TOTAL',
+                    'Valor': str(totales.get('total', 0)),
+                    'Tipo': 'Monetario' if idioma == 'Español' else 'Monetary'
+                })
+        except:
+            pass
     
+    df = pd.DataFrame(filas)
     df.to_csv(csv_filename, index=False, encoding='utf-8-sig', sep=',')
     
     return csv_filename
@@ -955,44 +1306,90 @@ with gr.Blocks(title="Extractor de Facturas con IA Avanzada") as demo:
         with gr.Tab("🔬 Análisis Avanzado IA"):
             gr.Markdown("""
             # 🎯 Suite Completa de Herramientas IA
-            ### Análisis profesional, detección de fraude, optimización fiscal y más
+            ### 12 herramientas profesionales de análisis automático
             """)
             
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 📊 Análisis de Sentimiento y Riesgos")
-                    btn_sentimiento = gr.Button("🔍 Analizar Riesgos", variant="primary")
-                    resultado_sentimiento = gr.Markdown()
-                    
-                    gr.Markdown("---")
-                    gr.Markdown("### 🚨 Detector de Fraude")
-                    btn_fraude = gr.Button("🛡️ Detectar Irregularidades", variant="primary")
-                    resultado_fraude = gr.Markdown()
-                    
-                    gr.Markdown("---")
-                    gr.Markdown("### 💰 Gastos Deducibles Fiscales")
-                    btn_deducibles = gr.Button("💸 Calcular Deducciones", variant="primary")
-                    resultado_deducibles = gr.Markdown()
-                    
-                    gr.Markdown("---")
-                    gr.Markdown("### 📁 Categorización Automática")
-                    btn_categoria = gr.Button("🏷️ Clasificar Gasto", variant="primary")
-                    resultado_categoria = gr.Markdown()
+            with gr.Tabs():
+                # Sub-tab 1: Análisis Financiero
+                with gr.Tab("💰 Análisis Financiero"):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### 📊 Análisis de Sentimiento")
+                            btn_sentimiento = gr.Button("🔍 Analizar Riesgos", variant="primary")
+                            resultado_sentimiento = gr.Markdown()
+                            
+                            gr.Markdown("---")
+                            gr.Markdown("### 💰 Gastos Deducibles")
+                            btn_deducibles = gr.Button("💸 Calcular Deducciones", variant="primary")
+                            resultado_deducibles = gr.Markdown()
+                            
+                            gr.Markdown("---")
+                            gr.Markdown("### 💵 Impacto Presupuestario")
+                            btn_impacto = gr.Button("📊 Calcular Impacto", variant="primary")
+                            resultado_impacto = gr.Markdown()
+                        
+                        with gr.Column():
+                            gr.Markdown("### 📅 Predicción de Pago")
+                            btn_prediccion = gr.Button("🔮 Fecha Óptima", variant="primary")
+                            resultado_prediccion = gr.Markdown()
+                            
+                            gr.Markdown("---")
+                            gr.Markdown("### 💡 Sugerencias IA")
+                            btn_sugerencias = gr.Button("✨ Generar Recomendaciones", variant="primary")
+                            resultado_sugerencias = gr.Markdown()
+                            
+                            gr.Markdown("---")
+                            gr.Markdown("### 📁 Categorización")
+                            btn_categoria = gr.Button("🏷️ Clasificar Gasto", variant="primary")
+                            resultado_categoria = gr.Markdown()
                 
-                with gr.Column():
-                    gr.Markdown("### 💡 Sugerencias Inteligentes")
-                    btn_sugerencias = gr.Button("✨ Generar Recomendaciones", variant="primary")
-                    resultado_sugerencias = gr.Markdown()
-                    
-                    gr.Markdown("---")
-                    gr.Markdown("### 📅 Predicción de Fecha de Pago")
-                    btn_prediccion = gr.Button("🔮 Predecir Fecha Óptima", variant="primary")
-                    resultado_prediccion = gr.Markdown()
+                # Sub-tab 2: Seguridad y Validación
+                with gr.Tab("🛡️ Seguridad y Validación"):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### 🚨 Detector de Fraude")
+                            btn_fraude = gr.Button("🛡️ Detectar Irregularidades", variant="primary")
+                            resultado_fraude = gr.Markdown()
+                            
+                            gr.Markdown("---")
+                            gr.Markdown("### 🔍 Detector de Duplicados")
+                            btn_duplicados = gr.Button("🔄 Buscar Duplicados", variant="primary")
+                            resultado_duplicados = gr.Markdown()
+                            
+                            gr.Markdown("---")
+                            gr.Markdown("### ✅ Validador Fiscal")
+                            btn_validador = gr.Button("📋 Validar Datos Fiscales", variant="primary")
+                            resultado_validador = gr.Markdown()
+                        
+                        with gr.Column():
+                            gr.Markdown("### 📝 Condiciones de Pago")
+                            btn_condiciones = gr.Button("📄 Analizar Condiciones", variant="primary")
+                            resultado_condiciones = gr.Markdown()
+                            
+                            gr.Markdown("---")
+                            gr.Markdown("### 🔔 Recordatorios de Pago")
+                            btn_recordatorios = gr.Button("⏰ Generar Recordatorios", variant="primary")
+                            resultado_recordatorios = gr.Markdown()
+                            
+                            gr.Markdown("---")
+                            gr.Markdown("### 📊 Resumen Ejecutivo")
+                            btn_ejecutivo = gr.Button("📈 Dashboard Gerencial", variant="primary")
+                            resultado_ejecutivo = gr.Markdown()
+                
+                # Sub-tab 3: Comparación y Mercado
+                with gr.Tab("📈 Análisis de Mercado"):
+                    gr.Markdown("### 💲 Comparador de Precios con Mercado")
+                    btn_mercado = gr.Button("🏪 Comparar con Mercado", variant="primary", size="lg")
+                    resultado_mercado = gr.Markdown()
                     
-                    gr.Markdown("---")
-                    gr.Markdown("### 📊 Resumen Ejecutivo")
-                    btn_ejecutivo = gr.Button("📈 Generar Dashboard", variant="primary")
-                    resultado_ejecutivo = gr.Markdown()
+                    gr.Markdown("""
+                    ---
+                    **Esta herramienta analiza:**
+                    - ✅ Precios competitivos vs mercado
+                    - ✅ Productos con precios elevados
+                    - ✅ Ahorro potencial estimado
+                    - ✅ Recomendaciones de negociación
+                    """)
         
         # ============= TAB 4: TRADUCCIÓN MULTIIDIOMA =============
         with gr.Tab("🌍 Traducción Internacional"):
@@ -1013,8 +1410,8 @@ with gr.Blocks(title="Extractor de Facturas con IA Avanzada") as demo:
                     
                     gr.Markdown("---")
                     gr.Markdown("### Exportar Traducción")
-                    btn_csv_traduccion = gr.Button("📥 Descargar CSV Traducido", variant="secondary")
-                    csv_traduccion_output = gr.File(label="📊 CSV de la Traducción")
+                    btn_csv_traduccion = gr.Button("📥 Descargar CSV Tabular Traducido", variant="secondary")
+                    csv_traduccion_output = gr.File(label="📊 CSV Traducido (Formato Tabular)")
                 
                 with gr.Column():
                     gr.Markdown("### 📝 Resultado de la Traducción")
@@ -1043,21 +1440,26 @@ with gr.Blocks(title="Extractor de Facturas con IA Avanzada") as demo:
     
     ---
     
-    ### 🎯 Funcionalidades Innovadoras:
+    ### 🎯 12 Funcionalidades IA Profesionales:
     
-    **🤖 Asistente Virtual:**
-    - Avatar robótico interactivo con animaciones
-    - Voz sintetizada de alta calidad
-    - Respuestas contextuales inteligentes
+    **💰 Análisis Financiero:**
+    - 🔍 **Análisis de Riesgos:** Detecta urgencias y alertas
+    - 💸 **Gastos Deducibles:** Calcula deducciones fiscales
+    - 📊 **Impacto Presupuestario:** Analiza impacto en presupuesto
+    - 🔮 **Predicción de Pagos:** Fecha óptima de pago
+    - ✨ **Sugerencias IA:** Recomendaciones personalizadas
+    - 🏷️ **Categorización:** Clasifica gastos automáticamente
     
-    **🔬 Suite Profesional:**
+    **🛡️ Seguridad y Validación:**
     - 🚨 **Detector de Fraude:** Identifica irregularidades
-    - 💰 **Gastos Deducibles:** Calcula deducciones fiscales
-    - 📅 **Predicción de Pagos:** Sugiere fechas óptimas
-    - 📊 **Resumen Ejecutivo:** Dashboard para gerencia
-    - 🔍 **Análisis de Riesgos:** Detecta urgencias
-    - 💡 **Sugerencias IA:** Recomendaciones personalizadas
-    - 📁 **Categorización:** Clasifica gastos automáticamente
+    - 🔄 **Detector de Duplicados:** Busca facturas duplicadas
+    - ✅ **Validador Fiscal:** Verifica datos fiscales
+    - 📄 **Análisis de Condiciones:** Evalúa términos de pago
+    - ⏰ **Recordatorios:** Plan de recordatorios inteligente
+    - 📈 **Dashboard Ejecutivo:** Resumen para gerencia
+    
+    **📈 Análisis de Mercado:**
+    - 💲 **Comparador de Precios:** Compara con mercado
     
     **📊 Formatos Mejorados:**
     - CSV tabular con comas como separador
@@ -1238,7 +1640,122 @@ with gr.Blocks(title="Extractor de Facturas con IA Avanzada") as demo:
         csv_file = traduccion_a_csv(traduccion, idioma)
         return csv_file
     
-    # Conectar eventos
+    def ejecutar_duplicados(datos_json):
+        if not datos_json:
+            return "❌ Procesa una factura primero"
+        token = os.getenv("aa")
+        if not token:
+            return "❌ Error de configuración"
+        client = InferenceClient(token=token)
+        resultado = detectar_facturas_duplicadas(datos_json, client)
+        return f"""### 🔄 Análisis de Duplicados
+
+**¿Es posible duplicado?** {'✅ SÍ' if resultado['posible_duplicado'] else '❌ NO'}  
+**Nivel de confianza:** {resultado['nivel_confianza'].upper()}
+
+**Indicadores:**
+{chr(10).join([f"- {ind}" for ind in resultado.get('indicadores', [])]) if resultado.get('indicadores') else '- No se detectaron indicadores'}
+
+**Recomendación:** {resultado['recomendacion']}"""
+    
+    def ejecutar_impacto(datos_json):
+        if not datos_json:
+            return "❌ Procesa una factura primero"
+        token = os.getenv("aa")
+        if not token:
+            return "❌ Error de configuración"
+        client = InferenceClient(token=token)
+        resultado = calcular_impacto_presupuesto(datos_json, client)
+        nivel_emoji = {"bajo": "🟢", "medio": "🟡", "alto": "🟠", "crítico": "🔴"}
+        return f"""### 📊 Impacto Presupuestario
+
+**Porcentaje del presupuesto:** {resultado['impacto_porcentaje']}%  
+**Nivel de impacto:** {nivel_emoji.get(resultado['nivel_impacto'], '⚪')} {resultado['nivel_impacto'].upper()}
+
+**Análisis:** {resultado['analisis']}
+
+**Recomendación Financiera:** {resultado['recomendacion_financiera']}"""
+    
+    def ejecutar_recordatorios(datos_json):
+        if not datos_json:
+            return "❌ Procesa una factura primero"
+        token = os.getenv("aa")
+        if not token:
+            return "❌ Error de configuración"
+        client = InferenceClient(token=token)
+        resultado = generar_recordatorios_pago(datos_json, client)
+        recordatorios = resultado.get('recordatorios', [])
+        texto = "### ⏰ Plan de Recordatorios de Pago\n\n"
+        for r in recordatorios:
+            texto += f"**{r.get('tipo', '').upper()}** ({r.get('dias_antes', 0)} días antes):\n"
+            texto += f"{r.get('mensaje', '')}\n\n"
+        return texto if recordatorios else "No se pudieron generar recordatorios"
+    
+    def ejecutar_condiciones(datos_json, texto):
+        if not datos_json:
+            return "❌ Procesa una factura primero"
+        token = os.getenv("aa")
+        if not token:
+            return "❌ Error de configuración"
+        client = InferenceClient(token=token)
+        resultado = analizar_condiciones_pago(datos_json, texto, client)
+        return f"""### 📄 Análisis de Condiciones de Pago
+
+**Plazo Actual:** {resultado['plazo_actual']}
+
+**Condiciones Especiales:**
+{chr(10).join([f"- {c}" for c in resultado.get('condiciones_especiales', [])]) if resultado.get('condiciones_especiales') else '- No detectadas'}
+
+**Oportunidades de Negociación:** {resultado['oportunidades_negociacion']}
+
+**Sugerencias de Mejora:** {resultado['sugerencias_mejora']}"""
+    
+    def ejecutar_mercado(datos_json):
+        if not datos_json:
+            return "❌ Procesa una factura primero"
+        token = os.getenv("aa")
+        if not token:
+            return "❌ Error de configuración"
+        client = InferenceClient(token=token)
+        resultado = comparar_precios_mercado(datos_json, client)
+        eval_emoji = {"competitivo": "✅", "normal": "⚪", "elevado": "⚠️"}
+        return f"""### 💲 Comparación con Precios de Mercado
+
+**Evaluación General:** {eval_emoji.get(resultado['evaluacion_general'], '⚪')} {resultado['evaluacion_general'].upper()}
+
+**Productos con Precios Elevados:**
+{chr(10).join([f"- {p}" for p in resultado.get('productos_caros', [])]) if resultado.get('productos_caros') else '- Todos los precios son razonables'}
+
+**Ahorro Potencial:** {resultado['ahorro_potencial']}€
+
+**Recomendación:** {resultado['recomendacion']}"""
+    
+    def ejecutar_validador(datos_json):
+        if not datos_json:
+            return "❌ Procesa una factura primero"
+        token = os.getenv("aa")
+        if not token:
+            return "❌ Error de configuración"
+        client = InferenceClient(token=token)
+        resultado = validar_datos_fiscales(datos_json, client)
+        return f"""### ✅ Validación de Datos Fiscales
+
+**¿Es válida?** {'✅ SÍ' if resultado['es_valida'] else '❌ NO'}  
+**Nivel de Cumplimiento:** {resultado['nivel_cumplimiento'].upper()}
+
+**Errores Detectados:**
+{chr(10).join([f"- ❌ {e}" for e in resultado.get('errores', [])]) if resultado.get('errores') else '- No se detectaron errores'}
+
+**Advertencias:**
+{chr(10).join([f"- ⚠️ {a}" for a in resultado.get('advertencias', [])]) if resultado.get('advertencias') else '- No hay advertencias'}"""
+    
+    # Conectar nuevas funcionalidades
+    btn_duplicados.click(fn=ejecutar_duplicados, inputs=[datos_json_state], outputs=[resultado_duplicados])
+    btn_impacto.click(fn=ejecutar_impacto, inputs=[datos_json_state], outputs=[resultado_impacto])
+    btn_recordatorios.click(fn=ejecutar_recordatorios, inputs=[datos_json_state], outputs=[resultado_recordatorios])
+    btn_condiciones.click(fn=ejecutar_condiciones, inputs=[datos_json_state, texto_extraido], outputs=[resultado_condiciones])
+    btn_mercado.click(fn=ejecutar_mercado, inputs=[datos_json_state], outputs=[resultado_mercado])
+    btn_validador.click(fn=ejecutar_validador, inputs=[datos_json_state], outputs=[resultado_validador])
     btn_sentimiento.click(fn=ejecutar_sentimiento, inputs=[texto_extraido], outputs=[resultado_sentimiento])
     btn_fraude.click(fn=ejecutar_fraude, inputs=[datos_json_state, texto_extraido], outputs=[resultado_fraude])
     btn_deducibles.click(fn=ejecutar_deducibles, inputs=[datos_json_state, texto_extraido], outputs=[resultado_deducibles])