app.py

import gradio as gr
import pandas as pd
import numpy as np
import tempfile
import os
from typing import Dict
from openai import OpenAI
from tqdm.auto import tqdm
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots

VARIABLES = {
    "Lugar de nacimiento": ["España", "Magreb", "Latinoamérica", "Otro país de Europa", "Otro lugar del mundo"],
    "Sexo": ["Hombre", "Mujer", "No binario"],
    "Generación": [
        "Z (1997-2012)",
        "Millennials (1981-1996)",
        "X (1965-1980)",
        "Baby Boomers (1946-1964)",
        "Silenciosa (1928-1945)"
    ],
    "Hábitat": ["Urbano", "Rural", "Semiurbano"],
    "Comunidad Autónoma": [
        "Andalucía", "Cataluña", "Madrid", "Comunidad Valenciana", "Galicia",
        "País Vasco", "Aragón", "Islas Baleares", "Canarias", "Castilla y León",
        "Castilla-La Mancha", "Asturias", "Navarra", "Murcia", "Extremadura",
        "Cantabria", "La Rioja", "Ceuta", "Melilla"
    ],
    "Nivel de Estudios": [
        "Sin estudios", "Primaria", "ESO", "Bachillerato",
        "FP Básica", "FP Medio", "FP Superior", "Grado Universitario",
        "Máster", "Doctorado"
    ],
    "Clase Social": [
        "Alta (Directivos, grandes empresarios)",
        "Media-Alta (Profesionales cualificados)",
        "Media (Técnicos, administrativos)",
        "Obreros cualificados",
        "Trabajadores no cualificados",
        "Pensionistas/Jubilados"
    ],
    "Hijos": ["Sí", "No"],
    "Profesión": [
        "Medicina/Salud", "Ingeniería/Tecnología", "Educación/Investigación",
        "Autónomo/Emprendedor", "Hostelería/Turismo", "Administración Pública",
        "Construcción/Obras", "Diseño/Arte", "Marketing/Comunicación",
        "Finanzas/Banca", "Legal/Abogacía", "Transporte/Logística",
        "Agricultura/Ganadería", "Fuerzas Armadas", "Cuidados/Asistencia",
        "Estudiante", "Desempleado", "Jubilado/Pensionista"
    ],
    "Aficiones": [
        "Deporte individual", "Deporte equipo", "Lectura", "Viajes",
        "Cine/Series", "Videojuegos", "Moda/Estilo", "Música/Conciertos",
        "Fotografía", "Jardinería", "Cocina", "Manualidades",
        "Voluntariado", "Tecnología", "Astronomía"
    ],
    "Tipo de Piel": [
        "Seca", "Grasa", "Mixta", "Sensible",
        "Normal", "Con tendencia acnéica", "Atópica"
    ],
    "Grado de preocupación": [
        "Ninguno", "Bajo", "Moderado", "Alto",
        "Muy alto (prioridad diaria)"
    ],
    "Productos usados": [
        "Ninguno", "Limpiador", "Tónico", "Crema hidratante",
        "Serum antioxidante", "Protector solar", "Contorno de ojos",
        "Mascarillas", "Exfoliante", "Tratamiento antiarrugas"
    ],
    "Canal de Compra": [
        "Farmacia/Parafarmacia", "Online (web marca)", "Marketplaces (Amazon)",
        "Supermercado", "Tiendas especializadas", "Centros comerciales",
        "Estética profesional", "Televenta"
    ]
}

def crear_grafico_frecuencias(df_resultados):
    """
    Crea gráficos de frecuencias para las respuestas de la encuesta con la orientación correcta.
    - Eje X: Opciones de respuesta
    - Eje Y: Frecuencia de cada opción
    """
    # Identificar las columnas de respuestas (empiezan con 'P')
    columnas_respuestas = [col for col in df_resultados.columns if col.startswith('P')]

    if not columnas_respuestas:
        return None

    # Determinar el número de filas y columnas para la disposición de los subgráficos
    n_preguntas = len(columnas_respuestas)
    n_cols = 2  # Máximo dos gráficos por fila
    n_rows = (n_preguntas + n_cols - 1) // n_cols  # Calcular filas necesarias

    # Crear la figura con subgráficos correctamente distribuidos
    fig = make_subplots(
        rows=n_rows, cols=n_cols,
        subplot_titles=columnas_respuestas,
        vertical_spacing=0.15,  # Espaciado entre gráficos
        horizontal_spacing=0.1
    )

    # Para cada pregunta, generar un gráfico de barras
    for i, pregunta in enumerate(columnas_respuestas):
        # Calcular frecuencias y porcentajes
        freq = df_resultados[pregunta].value_counts().sort_index()  # Asegurar orden de respuestas
        porcentajes = (freq / len(df_resultados) * 100).round(1)

        # Etiquetas con valores y porcentaje
        text = [f"{v} ({p}%)" for v, p in zip(freq.values, porcentajes.values)]

        # Determinar posición en la cuadrícula de subgráficos
        row = (i // n_cols) + 1
        col = (i % n_cols) + 1

        # Agregar gráfico de barras **vertical**, asegurando que X sean las categorías
        fig.add_trace(
            go.Bar(
                x=freq.index,  # 🔹 Categorías en el eje X (opciones de respuesta)
                y=freq.values,  # 🔹 Frecuencia en el eje Y
                text=text,
                textposition='outside',
                name=pregunta
            ),
            row=row,
            col=col
        )

        # Configurar los ejes correctamente
        fig.update_xaxes(title_text="Respuestas", tickangle=-45, row=row, col=col)
        fig.update_yaxes(title_text="Frecuencia", row=row, col=col)

    # Configurar el layout general
    fig.update_layout(
        title_text="Resultados de la Encuesta",
        showlegend=False,
        height=350 * n_rows,  # Ajustar altura dinámicamente
        width=1000,
        title_x=0.5
    )

    return fig


def procesar_respuesta_api(respuesta):
    """Extrae las respuestas del formato 'P1. a)' a un diccionario"""
    lines = respuesta.split('\n')
    responses = {}
    for line in lines:
        if line.strip():
            pregunta, respuesta = line.split('.')
            responses[pregunta.strip()] = respuesta.strip()
    return responses

def llamar_api_gpt(descripcion, encuesta, api_key):
    client = OpenAI(api_key=api_key)
    
    system_content = f"Eres una persona que responde a estas características: \n\n{descripcion}\n\nTu misión consiste en responder a una encuesta. Tu respuesta debe tener este formato. Número de pregunta y opción. Por ejemplo, P1. a), P2. b), etcétera.\n\n No necesitamos el texto de la respuesta, solo la letra de la opción. Es muy importante que respondas poniéndote en el rol que se te ha dado. No añadas espacios ni saltos de página. La encuesta es: "
    
    try:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {
                    "role": "system",
                    "content": [{"type": "text", "text": system_content}]
                },
                {
                    "role": "user",
                    "content": [{"type": "text", "text": encuesta}]
                }
            ],
            response_format={"type": "text"},
            temperature=0,
            max_completion_tokens=200,
            top_p=1,
            frequency_penalty=0,
            presence_penalty=0
        )
        return response.choices[0].message.content, None
    except Exception as e:
        return None, str(e)
def generar_entrevistado(config: Dict[str, Dict[str, float]], n: int) -> pd.DataFrame:
    """
    Genera un DataFrame con 'n' panelistas. Para cada variable de VARIABLES:
       - Si está en 'config', usa su distribución personalizada
       - Si no está, usa distribución uniforme
    """
    data = []
    for i in range(n):
        entrevistado = {"id_panelista": f"ID_{i+1:04d}"}
        
        # Asignar valor a cada variable
        for var, opciones in VARIABLES.items():
            if var in config:
                dist = list(config[var].values())  # p.ej. [0.3, 0.5, 0.2]
                suma = sum(dist)
                if suma > 0:
                    dist = [x / suma for x in dist]  # Normaliza
                else:
                    # Si suman 0, forzamos uniforme
                    dist = [1/len(opciones)] * len(opciones)
                valor = np.random.choice(opciones, p=dist)
            else:
                # Si no está en config => distribución uniforme
                valor = np.random.choice(opciones)
            
            entrevistado[var] = valor
        
        # Crear una descripción completa de la persona
        desc = (
            f"Se trata de una persona que ha nacido en {entrevistado['Lugar de nacimiento']},  de sexo {entrevistado['Sexo']} que pertenece a la Generación {entrevistado['Generación']}, "
            f"que reside en {entrevistado['Comunidad Autónoma']} (España), en un municipio de hábitat {entrevistado['Hábitat']}. "
            f"Posee un nivel de estudios {entrevistado['Nivel de Estudios']} y se ubica en la clase social {entrevistado['Clase Social']}. "
            f"{'Tiene hijos' if entrevistado['Hijos'] == 'Sí' else 'No tiene hijos'}. "
            f"Trabaja en {entrevistado['Profesión']} y sus aficiones principales son {entrevistado['Aficiones']}. "
            f"Su tipo de piel es {entrevistado['Tipo de Piel']}, con un grado de preocupación por el cuidado de la piel es {entrevistado['Grado de preocupación']}. "
            f"Actualmente usa {entrevistado['Productos usados']} y adquiere sus productos en {entrevistado['Canal de Compra']}."
        )
        entrevistado["Descripción"] = desc
        
        data.append(entrevistado)
    
    df = pd.DataFrame(data)
    return df
def lanzar_encuesta(df, texto_encuesta, api_key, progress=gr.Progress()):
    if not api_key:
        return None, None, "Error: Es necesario introducir una API Key de OpenAI", None
    
    if df is None or df.empty:
        return None, None, "Error: Primero debes generar una muestra de panelistas", None
    
    if not texto_encuesta:
        return None, None, "Error: Debes introducir el texto de la encuesta", None
            
    # Lista para almacenar resultados
    resultados = []
    errores = []
    
    # Información inicial
    total_panelistas = len(df)
    progress(0, desc=f"Iniciando encuesta para {total_panelistas} panelistas...")
    
    # Variables de perfil que queremos mantener (todas excepto 'Descripción')
    variables_perfil = [col for col in df.columns if col != 'Descripción']
    
    # Para cada panelista
    for i, (_, row) in enumerate(df.iterrows()):
        progress((i/total_panelistas), 
                desc=f"Procesando panelista {i+1} de {total_panelistas}")
        
        # Llamar a la API
        respuestas, error = llamar_api_gpt(
            row['Descripción'], 
            texto_encuesta,
            api_key
        )
        
        if error:
            errores.append(f"Error en panelista {row['id_panelista']}: {error}")
            continue
            
        try:
            # Procesar respuestas
            resp_dict = procesar_respuesta_api(respuestas)
            
            # Añadir todas las variables de perfil del panelista
            for var in variables_perfil:
                resp_dict[var] = row[var]
                
            resultados.append(resp_dict)
        except Exception as e:
            errores.append(f"Error procesando respuesta de {row['id_panelista']}: {str(e)}")
    
    # Crear mensaje de resumen
    total_exitosos = len(resultados)
    total_errores = len(errores)
    
    mensaje_resumen = f"""
    <h3>Resumen de la encuesta:</h3>
    <ul>
        <li>Total panelistas procesados: {total_panelistas}</li>
        <li>Respuestas exitosas: {total_exitosos}</li>
        <li>Errores encontrados: {total_errores}</li>
    </ul>
    """
    
    if errores:
        mensaje_resumen += "<h4>Detalle de errores:</h4><ul>"
        for error in errores:
            mensaje_resumen += f"<li>{error}</li>"
        mensaje_resumen += "</ul>"
    
    # Si no hay ningún resultado exitoso
    if not resultados:
        return None, None, mensaje_resumen, None
    
    # Crear DataFrame de resultados
    df_resultados = pd.DataFrame(resultados)
    
    # Reordenar las columnas para mejor visualización
    # Primero el ID, luego las variables de perfil, finalmente las respuestas
    columnas_respuestas = [col for col in df_resultados.columns 
                          if col not in variables_perfil]
    orden_columnas = ['id_panelista'] + \
                    [col for col in variables_perfil if col != 'id_panelista'] + \
                    columnas_respuestas
    
    df_resultados = df_resultados[orden_columnas]
    
    # Crear gráficos de frecuencias
    fig = crear_grafico_frecuencias(df_resultados)
    
    # Guardar a Excel
    with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
        df_resultados.to_excel(tmp.name, index=False)
        file_path = tmp.name
    
    progress(1.0, desc="¡Proceso completado!")
    return df_resultados, file_path, mensaje_resumen, fig
def crear_interfaz():
    with gr.Blocks(title="Generador de Panelistas Sintéticos") as app:
        gr.Markdown("## 🧴 Generador de Consumidores de Cremas Antiarrugas")
        
        # API Key de OpenAI
        api_key = gr.Textbox(
            label="OpenAI API Key",
            placeholder="Introduce tu API Key de OpenAI...",
            type="password"
        )
        
        # Tamaño de la muestra
        n_muestra = gr.Number(label="Tamaño de la muestra", value=100, precision=0)
        
        # Variables para el estado y progreso
        estado = gr.Textbox(label="Estado del proceso", value="Esperando acción...")
        progreso = gr.Progress()
        
        # Listas donde acumulamos todos los checkboxes y sliders
        all_checkboxes = []
        all_sliders = []
        vars_options = []
        
        with gr.Accordion("Configurar Distribuciones", open=False):
            for var, opciones in VARIABLES.items():
                with gr.Group():
                    gr.Markdown(f"### {var}")
                    
                    # Checkbox: si se quiere personalizar la distribución de esta variable
                    var_checkbox = gr.Checkbox(
                        label=f"Personalizar {var}",
                        value=False
                    )
                    all_checkboxes.append(var_checkbox)
                    
                    # Sliders para cada opción de la variable
                    for op in opciones:
                        s = gr.Slider(
                            minimum=0,
                            maximum=100,
                            step=1,
                            label=op,
                            value=100 / len(opciones)
                        )
                        all_sliders.append(s)
                    
                    # Guardar la info para reconstruir 'config' después
                    vars_options.append((var, opciones))

        # Salidas iniciales
        output_table = gr.Dataframe(label="Panelistas Generados")
        download_file = gr.File(label="Descargar Excel", file_count="single")
        
        # Nueva sección para la encuesta
        with gr.Accordion("Realizar Encuesta", open=False):
            encuesta_texto = gr.Textbox(
                label="Pegue aquí el texto de la encuesta",
                lines=10,
                placeholder="Pegue aquí las preguntas de la encuesta..."
            )
            info_encuesta = gr.HTML(label="Información de la encuesta")
            btn_encuesta = gr.Button("Lanzar Encuesta")
            
            # Sección de resultados de la encuesta
            with gr.Tab("Resultados"):
                resultados_encuesta = gr.Dataframe(label="Resultados Detallados")
                download_resultados = gr.File(label="Descargar Resultados Excel")
            
            # Nueva pestaña para los gráficos
            with gr.Tab("Gráficos"):
                graficos_resultados = gr.Plot(label="Gráficos de Frecuencias")

        # Botón generar muestra
        btn_generar = gr.Button("Generar Muestra", variant="primary")

        def generar(n, *values):
            """
            Recibe:
              - n (número)
              - un bloque de checkboxes (uno por variable)
              - un bloque de sliders (uno por opción de cada variable)
            """
            n_muestra_int = int(n)
            num_vars = len(vars_options)
            
            # Los primeros 'num_vars' valores son bool de checkboxes
            checks = values[:num_vars]
            # El resto son floats de sliders
            sliders = values[num_vars:]
            
            config_procesada = {}
            idx_slider = 0
            
            # Recorremos cada variable
            for i, (var, opciones) in enumerate(vars_options):
                if checks[i]:
                    # Personalizar
                    dist = {}
                    for op in opciones:
                        valor_slider = sliders[idx_slider]
                        idx_slider += 1
                        dist[op] = valor_slider / 100.0
                    config_procesada[var] = dist
                else:
                    # No se personaliza => avanzamos el índice de sliders sin usarlos
                    idx_slider += len(opciones)
            
            # Generar DF
            df = generar_entrevistado(config_procesada, n_muestra_int)
            
            # Guardar a Excel en un archivo temporal
            with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
                df.to_excel(tmp.name, index=False)
                file_path = tmp.name
            
            return df, file_path, "Muestra generada correctamente"
        
        # Conectar los botones
        btn_generar.click(
            fn=generar,
            inputs=[n_muestra] + all_checkboxes + all_sliders,
            outputs=[output_table, download_file, estado]
        )
        
        btn_encuesta.click(
            fn=lanzar_encuesta,
            inputs=[output_table, encuesta_texto, api_key],
            outputs=[resultados_encuesta, download_resultados, info_encuesta, graficos_resultados]
        )
        
    return app

# 4) Lanzar la app
if __name__ == "__main__":
    app = crear_interfaz()
    app.launch(debug=True)