El asistente está analizando...
""")
gr.Markdown("---")
gr.Markdown("#### Ejemplos de preguntas:")
gr.Markdown("""
- ¿Cuál es el total de la factura?
- ¿Qué es la base imponible?
- ¿Cuándo debo pagar esta factura?
- ¿Hay algún descuento aplicado?
- ¿Quién emitió esta factura?
""")
# Indicador de emoción
with gr.Column(scale=2):
gr.Markdown("### ")
gr.Markdown("### Respuesta a tu consulta")
resultado_ia = gr.Markdown(
value="*Haz una pregunta y el asistente te responderá aquí...*"
)
gr.Markdown("---")
gr.Markdown("### Lectura automática de la respuesta")
with gr.Row():
with gr.Column():
audio_respuesta = gr.Audio(
label=" Reproducir respuesta en audio",
type="filepath",
visible=True,
autoplay=True
)
with gr.Column():
transcripcion_output = gr.File(
label=" Descargar Transcripción (TXT)"
)
# ============= TAB 3: HERRAMIENTAS IA AVANZADAS =============
with gr.Tab("Consulta el analisis inteligente de tu factura"):
gr.Markdown("""
#### Verifica la información sensible
""")
with gr.Tabs():
# Sub-tab 1: Análisis Financiero
with gr.Tab(" Análisis IA"):
with gr.Row():
with gr.Column():
gr.Markdown("### ")
btn_sentimiento = gr.Button(" Riesgos", variant="primary")
resultado_sentimiento = gr.Markdown()
gr.Markdown("---")
gr.Markdown("### ")
btn_deducibles = gr.Button(" Calcular Deducciones", variant="primary")
resultado_deducibles = gr.Markdown()
gr.Markdown("---")
gr.Markdown("### ")
btn_impacto = gr.Button(" Impacto presupuestario", variant="primary")
resultado_impacto = gr.Markdown()
with gr.Column():
gr.Markdown("### ")
btn_prediccion = gr.Button(" Predicción de pago", variant="primary")
resultado_prediccion = gr.Markdown()
gr.Markdown("---")
gr.Markdown("### ")
btn_sugerencias = gr.Button(" Generar Recomendaciones", variant="primary")
resultado_sugerencias = gr.Markdown()
gr.Markdown("---")
gr.Markdown("### ")
btn_categoria = gr.Button(" Clasificar Gasto", variant="primary")
resultado_categoria = gr.Markdown()
# Sub-tab 2: Seguridad y Validación
with gr.Tab(" Análisis de riesgos"):
with gr.Row():
with gr.Column():
gr.Markdown("### ")
btn_fraude = gr.Button("Irregularidades", variant="primary")
resultado_fraude = gr.Markdown()
gr.Markdown("---")
gr.Markdown("### ")
btn_validador = gr.Button(" Datos Fiscales", variant="primary")
resultado_validador = gr.Markdown()
with gr.Column():
gr.Markdown("### ")
btn_condiciones = gr.Button(" Analizar Condiciones", variant="primary")
resultado_condiciones = gr.Markdown()
gr.Markdown("---")
gr.Markdown("### ")
btn_recordatorios = gr.Button(" Generar Recordatorios de pago", variant="primary")
resultado_recordatorios = gr.Markdown()
gr.Markdown("---")
gr.Markdown("### ")
btn_ejecutivo = gr.Button(" Dashboard Básico", variant="primary")
resultado_ejecutivo = gr.Markdown()
# Sub-tab 3: Comparación y Mercado
with gr.Tab(" Análisis IA de Mercado"):
gr.Markdown("### Comparador de Precios con Mercado")
btn_mercado = gr.Button(" Analizar", variant="primary", size="lg")
resultado_mercado = gr.Markdown()
# ============= TAB 4: TRADUCCIÓN MULTIIDIOMA CON TABLA =============
with gr.Tab(" Traduce tu factura a otro idioma"):
gr.Markdown("""
#
### Traduce tu factura a 5 idiomas con vista tabular y exporta a CSV
""")
with gr.Row():
with gr.Column():
gr.Markdown("### Seleccionar Idioma")
idioma_selector = gr.Dropdown(
choices=["Inglés", "Francés", "Alemán", "Italiano", "Portugués"],
value="Inglés",
label=" Selecciona un idioma"
)
btn_traducir = gr.Button(" Traducir Factura", variant="primary", size="lg")
gr.Markdown("---")
gr.Markdown("### Exportar Traducción")
csv_traduccion_output = gr.File(label=" Descargar CSV Tabular Traducido")
with gr.Column():
gr.Markdown("### Vista Tabular Traducida")
tabla_traduccion = gr.DataFrame(
label="Factura traducida en formato tabular",
wrap=True
)
gr.Markdown("---")
gr.Markdown("### Texto Traducido")
resultado_traduccion = gr.Textbox(
label="Resumen en texto",
lines=10,
placeholder="La traducción aparecerá aquí..."
)
gr.Markdown("---")
# ============= CONECTAR EVENTOS =============
# Extracción automática
def procesar_con_loading(pdf_file):
if pdf_file is None:
return "", None, None, "", "", None, None, None, gr.update(visible=False)
yield "", None, None, "", "", None, None, None, gr.update(visible=True)
time.sleep(0.5)
resultado = procesar_factura(pdf_file)
yield (*resultado, gr.update(visible=False))
btn_extraer.click(
fn=procesar_con_loading,
inputs=[pdf_input],
outputs=[texto_extraido, tabla_preview, csv_output, resumen_tecnico, info_util,
datos_json_state, csv_file_state, pdf_path_state, loading_extraccion]
)
# Generar PDF
btn_generar_pdf.click(
fn=generar_pdf_con_template,
inputs=[template_selector, csv_file_state, datos_json_state],
outputs=[pdf_output, pdf_status]
)
def consultar_ia_con_loading(texto, pregunta):
if not texto:
return ("❌ Por favor, procesa una factura primero", None, None, gr.update(visible=False))
yield ("🔄 El asistente está analizando tu pregunta...", None, None, gr.update(visible=True))
time.sleep(0.3)
try:
respuesta, audio, transcripcion = asistente_ia_factura(texto, pregunta)
audio_final = audio if (audio and os.path.exists(audio) and os.path.getsize(audio) > 100) else None
if audio_final:
print(f"✅ Audio disponible: {audio_final}")
else:
print("⚠️ Audio no disponible")
emocion_info += "\n\n⚠️ *El audio no pudo generarse, pero la respuesta está en texto.*"
yield (respuesta, audio_final, transcripcion, gr.update(visible=False))
except Exception as e:
error_msg = f"❌ Error: {str(e)[:200]}"
print(f"Error completo: {str(e)}")
yield (error_msg, None, None, gr.update(visible=False))
btn_consulta_ia.click(
fn=consultar_ia_con_loading,
inputs=[texto_extraido, pregunta_ia],
outputs=[resultado_ia, audio_respuesta, transcripcion_output, loading_ia]
)
# Funciones de análisis avanzado
def ejecutar_sentimiento(texto):
if not texto:
return "❌ Procesa una factura primero"
token = os.getenv("aa")
if not token:
return "❌ Error de configuración"
client = InferenceClient(token=token)
resultado = analizar_sentimiento_factura(texto, client)
emoji_sentimiento = {"positivo": "✅", "neutral": "⚪", "alerta": "⚠️"}
emoji_urgencia = {"alta": "🔴", "media": "🟡", "baja": "🟢"}
return f"""### {emoji_sentimiento.get(resultado['sentimiento'], '⚪')} Análisis de Sentimiento
**Estado:** {resultado['sentimiento'].upper()}
**Urgencia:** {emoji_urgencia.get(resultado['urgencia'], '⚪')} {resultado['urgencia'].upper()}
**Razón:** {resultado['razon']}
**Recomendación:** {resultado['recomendacion']}"""
def ejecutar_fraude(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 = detectar_fraude_factura(datos_json, texto, client)
nivel_color = {"bajo": "🟢", "medio": "🟡", "alto": "🔴"}
alertas_texto = "\n".join([f"- {alerta}" for alerta in resultado.get('alertas', [])])
return f"""### {nivel_color.get(resultado['nivel_riesgo'], '⚪')} Detección de Fraude
**Nivel de Riesgo:** {resultado['nivel_riesgo'].upper()}
**Alertas Detectadas:**
{alertas_texto if alertas_texto else "- No se detectaron alertas"}
**Recomendación:** {resultado['recomendacion']}"""
def ejecutar_deducibles(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 = extraer_gastos_deducibles(datos_json, texto, client)
return f"""### 💰 Análisis de Gastos Deducibles
**Porcentaje Deducible:** {resultado['porcentaje_deducible']}%
**Importe Deducible:** {resultado['importe_deducible']}€
**Tipo de Deducción:** {resultado['tipo_deduccion']}
**Explicación:** {resultado['explicacion']}
⚠️ *Nota: Esta es una estimación. Consulta con tu asesor fiscal.*"""
def ejecutar_sugerencias(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)
return f"### 💡 Sugerencias Personalizadas\n\n{generar_sugerencias_ia(datos_json, client)}"
def ejecutar_categoria(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)
return f"### 🏷️ Categorización Automática\n\n{extraer_categorias_gasto(datos_json, client)}"
def ejecutar_prediccion(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 = predecir_fecha_pago(datos_json, client)
return f"""### 📅 Predicción de Fecha de Pago Óptima
**Fecha Sugerida:** {resultado['fecha_sugerida']}
**Razón:** {resultado['razon']}
**Ahorro Posible:** {resultado['ahorro_posible']}
💡 Pagar en la fecha sugerida puede optimizar tu flujo de caja."""
def ejecutar_ejecutivo(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)
return f"### Resumen Ejecutivo - Dashboard\n\n{generar_resumen_ejecutivo(datos_json, client)}"
# Traducción completa con tabla
def ejecutar_traduccion_completa(texto, datos_json, idioma):
if not texto:
return "❌ Procesa una factura primero", None, None
token = os.getenv("aa")
if not token:
return "❌ Error de configuración", None, None
client = InferenceClient(token=token)
texto_traducido, df_traducido, csv_filename = traducir_factura_con_csv(datos_json, texto, idioma, client)
return texto_traducido, df_traducido, csv_filename
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 funcionalidades
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])
btn_sugerencias.click(fn=ejecutar_sugerencias, inputs=[datos_json_state], outputs=[resultado_sugerencias])
btn_categoria.click(fn=ejecutar_categoria, inputs=[datos_json_state], outputs=[resultado_categoria])
btn_prediccion.click(fn=ejecutar_prediccion, inputs=[datos_json_state], outputs=[resultado_prediccion])
btn_ejecutivo.click(fn=ejecutar_ejecutivo, inputs=[datos_json_state], outputs=[resultado_ejecutivo])
# Traducción con tabla
btn_traducir.click(
fn=ejecutar_traduccion_completa,
inputs=[texto_extraido, datos_json_state, idioma_selector],
outputs=[resultado_traduccion, tabla_traduccion, csv_traduccion_output]
)
if __name__ == "__main__":
demo.launch()