Update app.py

app.py

@@ -267,95 +267,58 @@ Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}
 """
     return informe, evaluacion['estado']
 
-def generar_graficos_actualizados(df_valid, n_replicas, unidad_medida,
-                                 palette_puntos, estilo_puntos,
-                                 palette_linea_ajuste, estilo_linea_ajuste,
-                                 palette_linea_ideal, estilo_linea_ideal,
-                                 palette_barras_error,
-                                 mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos):
-    # Función separada para evitar redundancia
-    return generar_graficos(df_valid, n_replicas, unidad_medida,
-                            palette_puntos, estilo_puntos,
-                            palette_linea_ajuste, estilo_linea_ajuste,
-                            palette_linea_ideal, estilo_linea_ideal,
-                            palette_barras_error,
-                            mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos)
-
-def evaluar_puntos_seleccionados(df, puntos_seleccionados):
-    if not puntos_seleccionados:
-        return df  # Si no se selecciona ningún punto, retornar el DataFrame completo
-
-    # Filtrar el DataFrame para incluir solo los puntos seleccionados
-    df_filtrado = df.iloc[puntos_seleccionados].reset_index(drop=True)
-    return df_filtrado
-
-def generar_lista_puntos(df):
+def generar_lista_puntos(df, unidad_medida):
     """Genera una lista de descripciones de puntos para el CheckboxGroup"""
     lista = []
     for idx, row in df.iterrows():
-        descripcion = f"Punto {idx + 1}: Predicha={row['Concentración Predicha (UFC)']}, Real Promedio={row['Concentración Real Promedio (UFC)']}"
+        predicha = row.get(f"Concentración Predicha ({unidad_medida})", "N/A")
+        real_promedio = row.get(f"Concentración Real Promedio ({unidad_medida})", "N/A")
+        descripcion = f"Punto {idx + 1}: Predicha={predicha}, Real Promedio={real_promedio}"
         lista.append(descripcion)
     return lista
 
-def actualizar_analisis(df, n_replicas, unidad_medida):
-    if df is None or df.empty:
-        return "Error en los datos", None, "No se pueden generar análisis", df
-
-    # Calcular promedio y desviación estándar dependiendo de las réplicas
-    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida)
-
-    col_predicha_num = "Concentración Predicha Numérica"
-    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
-
-    # Convertir columnas a numérico
-    df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
-
-    df_valid = df.dropna(subset=[col_predicha_num, col_real_promedio])
-
-    if len(df_valid) < 2:
-        return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df
-
-    # Calcular la regresión y agregar 'Ajuste Lineal'
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
-    df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
+def evaluar_puntos_seleccionados(df, puntos_seleccionados, unidad_medida):
+    if not puntos_seleccionados:
+        return df  # Si no se selecciona ningún punto, retornar el DataFrame completo
 
-    # Generar gráfico con opciones predeterminadas
-    fig = generar_graficos(
-        df_valid, n_replicas, unidad_medida,
-        palette_puntos='deep', estilo_puntos='o',
-        palette_linea_ajuste='muted', estilo_linea_ajuste='-',
-        palette_linea_ideal='bright', estilo_linea_ideal='--',
-        palette_barras_error='pastel',
-        mostrar_linea_ajuste=True, mostrar_linea_ideal=True, mostrar_puntos=True
-    )
-    informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida)
+    # Crear una lista de descripciones para comparación
+    lista_puntos = generar_lista_puntos(df, unidad_medida)
 
-    return estado, fig, informe, df
+    # Filtrar el DataFrame para incluir solo los puntos seleccionados
+    indices_seleccionados = [lista_puntos.index(punto) for punto in puntos_seleccionados if punto in lista_puntos]
+    df_filtrado = df.iloc[indices_seleccionados].reset_index(drop=True)
+    return df_filtrado
 
-def actualizar_graficos(df, n_replicas, unidad_medida,
-                        palette_puntos, estilo_puntos,
-                        palette_linea_ajuste, estilo_linea_ajuste,
-                        palette_linea_ideal, estilo_linea_ideal,
-                        palette_barras_error,
-                        mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos):
+def recalcular(df, n_replicas, unidad_medida, puntos_seleccionados,
+              palette_puntos, estilo_puntos,
+              palette_linea_ajuste, estilo_linea_ajuste,
+              palette_linea_ideal, estilo_linea_ideal,
+              palette_barras_error,
+              mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos):
     if df is None or df.empty:
-        return None
+        return "Error en los datos", None, "No se pueden generar análisis", df, gr.CheckboxGroup.update(choices=[], value=[])
 
     # Calcular promedio y desviación estándar
     df = calcular_promedio_desviacion(df, n_replicas, unidad_medida)
 
+    # Filtrar los puntos seleccionados
+    df_filtrado = evaluar_puntos_seleccionados(df, puntos_seleccionados, unidad_medida)
+
     col_predicha_num = "Concentración Predicha Numérica"
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
-    df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
+    df_filtrado[col_predicha_num] = pd.to_numeric(df_filtrado[col_predicha_num], errors='coerce')
+    df_filtrado[col_real_promedio] = pd.to_numeric(df_filtrado[col_real_promedio], errors='coerce')
 
-    df_valid = df.dropna(subset=[col_predicha_num, col_real_promedio])
+    df_valid = df_filtrado.dropna(subset=[col_predicha_num, col_real_promedio])
 
     if len(df_valid) < 2:
-        return None
+        return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df, gr.CheckboxGroup.update(choices=[], value=[])
+
+    # Calcular la regresión y agregar 'Ajuste Lineal'
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
+    df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
     # Generar gráfico con opciones seleccionadas
     fig = generar_graficos(
@@ -367,56 +330,54 @@ def actualizar_graficos(df, n_replicas, unidad_medida,
         mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos
     )
 
-    return fig
+    # Generar informe
+    informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida)
 
-def recalcular(df, n_replicas, unidad_medida, puntos_seleccionados,
-              palette_puntos, estilo_puntos,
-              palette_linea_ajuste, estilo_linea_ajuste,
-              palette_linea_ideal, estilo_linea_ideal,
-              palette_barras_error,
-              mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos):
+    # Generar lista de puntos para selección
+    lista_puntos = generar_lista_puntos(df, unidad_medida)
+
+    return estado, fig, informe, df, gr.CheckboxGroup.update(choices=lista_puntos, value=puntos_seleccionados)
+
+def actualizar_analisis(df, n_replicas, unidad_medida):
     if df is None or df.empty:
-        return "Error en los datos", None, "No se pueden generar análisis", df, []
+        return "Error en los datos", None, "No se pueden generar análisis", df
 
-    # Calcular promedio y desviación estándar
+    # Calcular promedio y desviación estándar dependiendo de las réplicas
     df = calcular_promedio_desviacion(df, n_replicas, unidad_medida)
 
-    # Filtrar los puntos seleccionados
-    df_filtrado = evaluar_puntos_seleccionados(df, puntos_seleccionados)
-
     col_predicha_num = "Concentración Predicha Numérica"
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
-    df_filtrado[col_predicha_num] = pd.to_numeric(df_filtrado[col_predicha_num], errors='coerce')
-    df_filtrado[col_real_promedio] = pd.to_numeric(df_filtrado[col_real_promedio], errors='coerce')
+    df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
+    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
 
-    df_valid = df_filtrado.dropna(subset=[col_predicha_num, col_real_promedio])
+    df_valid = df.dropna(subset=[col_predicha_num, col_real_promedio])
 
     if len(df_valid) < 2:
-        return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df, []
+        return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df
 
     # Calcular la regresión y agregar 'Ajuste Lineal'
     slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
-    # Generar gráfico con opciones seleccionadas
+    # Generar gráfico con opciones predeterminadas
     fig = generar_graficos(
         df_valid, n_replicas, unidad_medida,
-        palette_puntos, estilo_puntos,
-        palette_linea_ajuste, estilo_linea_ajuste,
-        palette_linea_ideal, estilo_linea_ideal,
-        palette_barras_error,
-        mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos
+        palette_puntos='deep', estilo_puntos='o',
+        palette_linea_ajuste='muted', estilo_linea_ajuste='-',
+        palette_linea_ideal='bright', estilo_linea_ideal='--',
+        palette_barras_error='pastel',
+        mostrar_linea_ajuste=True, mostrar_linea_ideal=True, mostrar_puntos=True
     )
 
     # Generar informe
     informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida)
 
     # Generar lista de puntos para selección
-    lista_puntos = generar_lista_puntos(df)
+    lista_puntos = generar_lista_puntos(df, unidad_medida)
 
-    return estado, fig, informe, df, lista_puntos
+    return estado, fig, informe, df, gr.CheckboxGroup.update(choices=lista_puntos, value=lista_puntos)
 
 def exportar_informe_word(df_valid, informe_md, unidad_medida):
     # Crear documento Word
@@ -446,7 +407,10 @@ def exportar_informe_word(df_valid, informe_md, unidad_medida):
         leyenda = doc.add_paragraph('Figura 1. Gráfico de calibración.')
         leyenda_format = leyenda.paragraph_format
         leyenda_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-        leyenda.style = doc.styles['Caption']
+        if 'Caption' in doc.styles:
+            leyenda.style = doc.styles['Caption']
+        else:
+            leyenda.style = doc.styles['Normal']  # Fallback si no existe 'Caption'
 
     # Agregar contenido del informe
     doc.add_heading('Resumen Estadístico', level=1)
@@ -527,10 +491,10 @@ def exportar_word(df, informe_md, unidad_medida):
 
     return filename  # Retornamos el nombre del archivo
 
-def exportar_latex(df, informe_md):
+def exportar_latex(df, informe_md, unidad_medida):
     df_valid = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
-    col_real_promedio = [col for col in df_valid.columns if 'Real Promedio' in col][0]
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
     df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
@@ -676,7 +640,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             with gr.Column(scale=3):
                 graficos_output = gr.Plot(label="Gráficos de Análisis")
                 with gr.Row():
-                    # Opciones y botones debajo del gráfico
+                    # Botones debajo del gráfico
                     graficar_btn = gr.Button("📊 Graficar", variant="primary")
             with gr.Column(scale=1):
                 puntos_seleccionados = gr.CheckboxGroup(
@@ -744,19 +708,31 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         informe_output = gr.Markdown(elem_id="informe_output")
 
         # Eventos
-        input_components = [tabla_output]
-        output_components = [estado_output, graficos_output, informe_output, tabla_output]
 
         # Evento al presionar el botón Calcular
         calcular_btn.click(
             fn=actualizar_analisis,
             inputs=[tabla_output, replicas_slider, unidad_input],
-            outputs=[estado_output, graficos_output, informe_output, tabla_output]
+            outputs=[estado_output, graficos_output, informe_output, tabla_output, puntos_seleccionados]
         )
 
         # Evento para graficar con opciones seleccionadas
         graficar_btn.click(
-            fn=actualizar_graficos,
+            fn=lambda df, n_replicas, unidad_medida, pal_p, est_p, pal_aj, est_aj, pal_id, est_id, pal_be, m_aj, m_id, m_p: generar_graficos(
+                calcular_promedio_desviacion(df, n_replicas, unidad_medida),
+                n_replicas,
+                unidad_medida,
+                pal_p,
+                est_p,
+                pal_aj,
+                est_aj,
+                pal_id,
+                est_id,
+                pal_be,
+                m_aj,
+                m_id,
+                m_p
+            ),
             inputs=[
                 tabla_output, replicas_slider, unidad_input,
                 palette_puntos_dropdown, estilo_puntos_dropdown,
@@ -787,20 +763,20 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         limpiar_btn.click(
             fn=limpiar_datos,
             inputs=[replicas_slider],
-            outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
+            outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, puntos_seleccionados]
         )
 
         # Eventos de los botones de ejemplo
         ejemplo_ufc_btn.click(
             fn=cargar_ejemplo_ufc,
             inputs=[replicas_slider],
-            outputs=[concentracion_input, unidad_input, filas_slider, tabla_output]
+            outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, puntos_seleccionados]
         )
 
         ejemplo_od_btn.click(
             fn=cargar_ejemplo_od,
             inputs=[replicas_slider],
-            outputs=[concentracion_input, unidad_input, filas_slider, tabla_output]
+            outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, puntos_seleccionados]
         )
 
         # Evento para generar datos sintéticos
@@ -874,8 +850,8 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         )
 
         exportar_latex_btn.click(
-            fn=exportar_latex,
-            inputs=[tabla_output, informe_output],
+            fn=lambda df, informe_md, unidad_medida: exportar_latex(df, informe_md, unidad_medida),
+            inputs=[tabla_output, informe_output, unidad_input],
             outputs=exportar_latex_file
         )
 
@@ -885,17 +861,16 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             df = generar_tabla(7, 2000000, "UFC", n_replicas)
             # Valores reales de ejemplo
             df[f"Concentración Real 1 (UFC)"] = [2000000, 1600000, 1200000, 800000, 400000, 200000, 100000]
-            estado, fig, informe, df = actualizar_analisis(df, n_replicas, "UFC")
-            lista_puntos = generar_lista_puntos(df)
+            estado, fig, informe, df_actualizado, lista_puntos_update = actualizar_analisis(df, n_replicas, "UFC")
             return (
                 2000000,
                 "UFC",
                 7,
-                df,
+                df_actualizado,
                 estado,
                 fig,
                 informe,
-                lista_puntos
+                lista_puntos_update
             )
 
         interfaz.load(