Update app.py

app.py

@@ -4,7 +4,7 @@ import numpy as np
 import tempfile
 import os
 from typing import Dict
-import openai
+from openai import OpenAI
 from tqdm.auto import tqdm
 import plotly.express as px
 import plotly.graph_objects as go
@@ -79,26 +79,36 @@ def crear_grafico_frecuencias(df_resultados):
     """
     Crea gráficos de frecuencias para las respuestas de la encuesta
     """
+    # 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
         
+    # Crear una figura con subplots
     n_preguntas = len(columnas_respuestas)
-    n_rows = (n_preguntas + 1) // 2
+    n_rows = (n_preguntas + 1) // 2  # Dos gráficos por fila
     fig = make_subplots(rows=n_rows, cols=2, 
                        subplot_titles=columnas_respuestas,
                        vertical_spacing=0.1,
                        horizontal_spacing=0.1)
     
+    # Para cada pregunta
     for i, pregunta in enumerate(columnas_respuestas):
+        # Calcular frecuencias
         freq = df_resultados[pregunta].value_counts()
+        
+        # Calcular porcentajes
         porcentajes = (freq / len(df_resultados) * 100).round(1)
+        
+        # Crear texto para las barras (frecuencia y porcentaje)
         text = [f"{v} ({p}%)" for v, p in zip(freq.values, porcentajes.values)]
         
+        # Determinar posición en el subplot
         row = (i // 2) + 1
         col = (i % 2) + 1
         
+        # Añadir barra
         fig.add_trace(
             go.Bar(
                 x=freq.index,
@@ -111,9 +121,11 @@ def crear_grafico_frecuencias(df_resultados):
             col=col
         )
         
+        # Actualizar layout del subplot
         fig.update_xaxes(title_text="Respuestas", row=row, col=col)
         fig.update_yaxes(title_text="Frecuencia", row=row, col=col)
     
+    # Actualizar layout general
     fig.update_layout(
         title_text="Resultados de la Encuesta",
         showlegend=False,
@@ -135,49 +147,61 @@ def procesar_respuesta_api(respuesta):
     return responses
 
 def llamar_api_gpt(descripcion, encuesta, api_key):
-    openai.api_key = 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\nEs 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 = openai.ChatCompletion.create(
+        response = client.chat.completions.create(
             model="gpt-4o",
             messages=[
-                {"role": "system", "content": system_content},
-                {"role": "user", "content": encuesta}
+                {
+                    "role": "system",
+                    "content": [{"type": "text", "text": system_content}]
+                },
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": encuesta}]
+                }
             ],
+            response_format={"type": "text"},
             temperature=0,
-            max_tokens=200,
+            max_completion_tokens=200,
             top_p=1,
             frequency_penalty=0,
             presence_penalty=0
         )
-        return response.choices[0].message['content'], None
+        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
+    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())
+                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]
+                    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']}. "
@@ -193,7 +217,6 @@ def generar_entrevistado(config: Dict[str, Dict[str, float]], n: int) -> pd.Data
     
     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
@@ -204,18 +227,23 @@ def lanzar_encuesta(df, texto_encuesta, api_key, progress=gr.Progress()):
     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,
@@ -227,8 +255,10 @@ def lanzar_encuesta(df, texto_encuesta, api_key, progress=gr.Progress()):
             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]
                 
@@ -236,6 +266,7 @@ def lanzar_encuesta(df, texto_encuesta, api_key, progress=gr.Progress()):
         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)
     
@@ -254,11 +285,15 @@ def lanzar_encuesta(df, texto_encuesta, api_key, progress=gr.Progress()):
             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'] + \
@@ -267,30 +302,35 @@ def lanzar_encuesta(df, texto_encuesta, api_key, progress=gr.Progress()):
     
     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 = []
@@ -300,12 +340,14 @@ def crear_interfaz():
                 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,
@@ -316,11 +358,14 @@ def crear_interfaz():
                         )
                         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",
@@ -330,27 +375,40 @@ def crear_interfaz():
             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]
@@ -358,16 +416,20 @@ def crear_interfaz():
                         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,
@@ -382,4 +444,7 @@ def crear_interfaz():
         
     return app
 
-app = crear_interfaz()
+# 4) Lanzar la app
+if __name__ == "__main__":
+    app = crear_interfaz()
+    app.launch()