Update app.py

app.py

@@ -83,13 +83,13 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
     col_desviacion = f"Desviación Estándar ({unidad_medida})"
 
     # Convertir a numérico
-    df_valid.loc[:, col_predicha_num] = df_valid[col_predicha_num].astype(float)
-    df_valid.loc[:, col_real_promedio] = df_valid[col_real_promedio].astype(float)
-    df_valid.loc[:, col_desviacion] = df_valid[col_desviacion].fillna(0).astype(float)
+    df_valid[col_predicha_num] = df_valid[col_predicha_num].astype(float)
+    df_valid[col_real_promedio] = df_valid[col_real_promedio].astype(float)
+    df_valid[col_desviacion] = df_valid[col_desviacion].fillna(0).astype(float)
 
     # Calcular regresión lineal
     slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
-    df_valid.loc[:, 'Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
+    df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
     # Configurar estilos
     sns.set(style="whitegrid")
@@ -229,8 +229,8 @@ def generar_informe_completo(df_valid, n_replicas, unidad_medida):
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir a numérico
-    df_valid.loc[:, col_predicha_num] = df_valid[col_predicha_num].astype(float)
-    df_valid.loc[:, col_real_promedio] = df_valid[col_real_promedio].astype(float)
+    df_valid[col_predicha_num] = df_valid[col_predicha_num].astype(float)
+    df_valid[col_real_promedio] = df_valid[col_real_promedio].astype(float)
 
     # Calcular estadísticas
     slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
@@ -267,22 +267,10 @@ Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}
 """
     return informe, evaluacion['estado']
 
-def actualizar_analisis(df, n_replicas, unidad_medida, absorbancia_blanco, *replicas):
+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
 
-    # Actualizar los valores de las réplicas desde los cuadros de texto
-    for i, replica in enumerate(replicas):
-        if replica is not None:
-            col_real = f"Concentración Real {i + 1} ({unidad_medida})"
-            df.loc[0, col_real] = replica
-
-    # Ajustar valores de absorbancia reales por el valor del blanco
-    for i in range(1, n_replicas + 1):
-        col_real = f"Concentración Real {i} ({unidad_medida})"
-        df.loc[:, col_real] = pd.to_numeric(df[col_real], errors='coerce')
-        df.loc[:, col_real] = df[col_real] - absorbancia_blanco
-
     # Calcular promedio y desviación estándar dependiendo de las réplicas
     df = calcular_promedio_desviacion(df, n_replicas, unidad_medida)
 
@@ -290,8 +278,8 @@ def actualizar_analisis(df, n_replicas, unidad_medida, absorbancia_blanco, *repl
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
-    df.loc[:, col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-    df.loc[:, col_real_promedio] = pd.to_numeric(df[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.dropna(subset=[col_predicha_num, col_real_promedio])
 
@@ -300,7 +288,7 @@ def actualizar_analisis(df, n_replicas, unidad_medida, absorbancia_blanco, *repl
 
     # 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.loc[:, 'Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
+    df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
     # Generar gráfico con opciones predeterminadas
     fig = generar_graficos(
@@ -331,8 +319,8 @@ def actualizar_graficos(df, n_replicas, unidad_medida,
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
-    df.loc[:, col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-    df.loc[:, col_real_promedio] = pd.to_numeric(df[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.dropna(subset=[col_predicha_num, col_real_promedio])
 
@@ -442,14 +430,14 @@ def exportar_informe_latex(df_valid, informe_md):
         f.write(informe_tex)
     return filename
 
-def exportar_word(df, informe_md, unidad_medida, absorbancia_blanco):
+def exportar_word(df, informe_md, unidad_medida):
     df_valid = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
-    df_valid.loc[:, col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
-    df_valid.loc[:, col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
+    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
 
     df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio])
 
@@ -466,8 +454,8 @@ def exportar_latex(df, informe_md):
     col_real_promedio = [col for col in df_valid.columns if 'Real Promedio' in col][0]
 
     # Convertir columnas a numérico
-    df_valid.loc[:, col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
-    df_valid.loc[:, col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
+    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
 
     df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio])
 
@@ -478,26 +466,6 @@ def exportar_latex(df, informe_md):
 
     return filename  # Retornamos el nombre del archivo
 
-def limpiar_datos(n_replicas):
-    df = generar_tabla(7, 1.0, "OD", n_replicas)
-    return (
-        1.0,   # Concentración Inicial
-        "OD",     # Unidad de Medida
-        7,         # Número de filas
-        df,        # Tabla Output
-        "",        # Estado Output
-        None,      # Gráficos Output
-        ""         # Informe Output
-    )
-
-def subir_datos_replica(df, n_replicas, unidad_medida, datos_replica):
-    df = df.copy()
-    for i, dato in enumerate(datos_replica):
-        if dato is not None:
-            col_real = f"Concentración Real {i + 1} ({unidad_medida})"
-            df.loc[0, col_real] = dato
-    return df
-
 # Funciones de ejemplo
 def cargar_ejemplo_ufc(n_replicas):
     df = generar_tabla(7, 2000000, "UFC", n_replicas)
@@ -519,20 +487,32 @@ def cargar_ejemplo_od(n_replicas):
         df[f"Concentración Real {i} (OD)"] = valores_reales
     return 1.0, "OD", 7, df
 
-def generar_datos_sinteticos_evento(df, n_replicas, unidad_medida, absorbancia_blanco):
+def limpiar_datos(n_replicas):
+    df = generar_tabla(7, 2000000, "UFC", n_replicas)
+    return (
+        2000000,   # Concentración Inicial
+        "UFC",     # Unidad de Medida
+        7,         # Número de filas
+        df,        # Tabla Output
+        "",        # Estado Output
+        None,      # Gráficos Output
+        ""         # Informe Output
+    )
+
+def generar_datos_sinteticos_evento(df, n_replicas, unidad_medida):
     df = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
 
     # Generar datos sintéticos para cada réplica
     for i in range(1, n_replicas + 1):
         col_real = f"Concentración Real {i} ({unidad_medida})"
-        df.loc[:, col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
+        df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
         desviacion_std = 0.05 * df[col_predicha_num].mean()  # 5% de la media como desviación estándar
         valores_predichos = df[col_predicha_num].astype(float).values
         datos_sinteticos = valores_predichos + np.random.normal(0, desviacion_std, size=len(valores_predichos))
         datos_sinteticos = np.maximum(0, datos_sinteticos)  # Asegurar que no haya valores negativos
         datos_sinteticos = np.round(datos_sinteticos, 2)
-        df.loc[:, col_real] = datos_sinteticos - absorbancia_blanco
+        df[col_real] = datos_sinteticos
 
     return df
 
@@ -546,7 +526,7 @@ def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas):
 
     # Reemplazar valores existentes en "Concentración Real"
     for col_new, col_old in zip(col_real_new, col_real_old):
-        df_new.loc[:, col_new] = None
+        df_new[col_new] = None
         for idx in df_new.index:
             if idx in df.index:
                 df_new.at[idx, col_new] = df.at[idx, col_old]
@@ -563,14 +543,14 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     with gr.Tab("📝 Datos de Calibración"):
         with gr.Row():
             concentracion_input = gr.Number(
-                value=1.0,
+                value=2000000,
                 label="Concentración Inicial",
-                precision=2
+                precision=0
             )
             unidad_input = gr.Textbox(
-                value="OD",
+                value="UFC",
                 label="Unidad de Medida",
-                placeholder="OD, UFC, etc..."
+                placeholder="UFC, OD, etc..."
             )
             filas_slider = gr.Slider(
                 minimum=1,
@@ -593,26 +573,17 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
                 step=1,
                 label="Número de Réplicas"
             )
-            absorbancia_blanco_input = gr.Number(
-                value=0.0,
-                label="Absorbancia del Blanco",
-                precision=2
-            )
 
         with gr.Row():
             calcular_btn = gr.Button("🔄 Calcular", variant="primary")
             limpiar_btn = gr.Button("🗑 Limpiar Datos", variant="secondary")
             ajustar_decimales_btn = gr.Button("🛠 Ajustar Decimales", variant="secondary")
-            subir_datos_btn = gr.Button("📤 Subir Datos de Réplica", variant="secondary")
 
         with gr.Row():
             ejemplo_ufc_btn = gr.Button("📋 Cargar Ejemplo UFC", variant="secondary")
             ejemplo_od_btn = gr.Button("📋 Cargar Ejemplo OD", variant="secondary")
             sinteticos_btn = gr.Button("🧪 Generar Datos Sintéticos", variant="secondary")
 
-        with gr.Row():
-            replica_inputs = [gr.Textbox(label=f"Réplica {i + 1}") for i in range(10)]
-
         tabla_output = gr.DataFrame(
             wrap=True,
             label="Tabla de Datos",
@@ -690,7 +661,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     # Evento al presionar el botón Calcular
     calcular_btn.click(
         fn=actualizar_analisis,
-        inputs=[tabla_output, replicas_slider, unidad_input, absorbancia_blanco_input, *replica_inputs],
+        inputs=[tabla_output, replicas_slider, unidad_input],
         outputs=output_components
     )
 
@@ -715,13 +686,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
     )
 
-    # Evento para subir datos de réplica
-    subir_datos_btn.click(
-        fn=subir_datos_replica,
-        inputs=[tabla_output, replicas_slider, unidad_input, *replica_inputs],
-        outputs=tabla_output
-    )
-
     # Eventos de los botones de ejemplo
     ejemplo_ufc_btn.click(
         fn=cargar_ejemplo_ufc,
@@ -738,7 +702,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     # Evento para generar datos sintéticos
     sinteticos_btn.click(
         fn=generar_datos_sinteticos_evento,
-        inputs=[tabla_output, replicas_slider, unidad_input, absorbancia_blanco_input],
+        inputs=[tabla_output, replicas_slider, unidad_input],
         outputs=tabla_output
     )
 
@@ -801,7 +765,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     # Eventos de exportar informes
     exportar_word_btn.click(
         fn=exportar_word,
-        inputs=[tabla_output, informe_output, unidad_input, absorbancia_blanco_input],
+        inputs=[tabla_output, informe_output, unidad_input],
         outputs=exportar_word_file
     )
 
@@ -814,24 +778,23 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     # Inicializar la interfaz con el ejemplo base
     def iniciar_con_ejemplo():
         n_replicas = 1
-        df = generar_tabla(7, 1.0, "OD", n_replicas)
+        df = generar_tabla(7, 2000000, "UFC", n_replicas)
         # Valores reales de ejemplo
-        df[f"Concentración Real 1 (OD)"] = [1.00, 0.80, 0.60, 0.40, 0.20, 0.10, 0.05]
-        estado, fig, informe, df = actualizar_analisis(df, n_replicas, "OD", 0.0)
+        df[f"Concentración Real 1 (UFC)"] = [2000000, 1600000, 1200000, 800000, 400000, 200000, 100000]
+        estado, fig, informe, df = actualizar_analisis(df, n_replicas, "UFC")
         return (
-            1.0,
-            "OD",
+            2000000,
+            "UFC",
             7,
             df,
             estado,
             fig,
-            informe,
-            0.0
+            informe
         )
 
     interfaz.load(
         fn=iniciar_con_ejemplo,
-        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, absorbancia_blanco_input]
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
     )
 
 # Lanzar la interfaz