Update app.py

app.py

@@ -1,314 +1,835 @@
-# -*- coding: utf-8 -*-
-"""PrediLectia - Gradio Final v2 with Multiple Y-Axes in Combined Plot.ipynb"""
-
-# Instalación de librerías necesarias
-#!pip install gradio seaborn scipy -q
+import gradio as gr
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy import stats
+from datetime import datetime
+import docx
+from docx.shared import Inches, Pt
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
 import os
-os.system('pip install gradio seaborn scipy scikit-learn openpyxl pydantic==1.10.0')
 
-from pydantic import BaseModel, ConfigDict
+def generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas):
+    valores_base = [1.00, 0.80, 0.60, 0.40, 0.20, 0.10, 0.05]
+
+    if n_filas <= 7:
+        solucion_inoculo = valores_base[:n_filas]
+        agua = [round(1 - x, 2) for x in solucion_inoculo]
+    else:
+        solucion_inoculo = valores_base.copy()
+        ultimo_valor = valores_base[-1]
+        for _ in range(n_filas - 7):
+            nuevo_valor = round(ultimo_valor / 2, 3)
+            solucion_inoculo.append(nuevo_valor)
+            ultimo_valor = nuevo_valor
+        agua = [round(1 - x, 3) for x in solucion_inoculo]
+
+    data = {
+        f"Solución de inóculo ({concentracion_inicial} {unidad_medida})": solucion_inoculo,
+        "H2O": agua
+    }
+    df = pd.DataFrame(data)
+
+    nombre_columna = f"Solución de inóculo ({concentracion_inicial} {unidad_medida})"
+    df["Factor de Dilución"] = df[nombre_columna].apply(lambda x: round(1 / x, 2))
+    df["Concentración Predicha Numérica"] = df["Factor de Dilución"].apply(
+        lambda x: concentracion_inicial / x
+    )
+    df[f"Concentración Predicha ({unidad_medida})"] = df["Concentración Predicha Numérica"].round(0).astype(str)
+
+    # Añadir columnas para las réplicas de "Concentración Real"
+    for i in range(1, n_replicas + 1):
+        df[f"Concentración Real {i} ({unidad_medida})"] = None
+
+    # Las columnas de promedio y desviación estándar se agregarán durante el análisis
+    return df
+
+def ajustar_decimales_evento(df, decimales):
+    df = df.copy()
+    # Ajustar decimales en todas las columnas numéricas
+    for col in df.columns:
+        try:
+            df[col] = pd.to_numeric(df[col], errors='ignore')
+            df[col] = df[col].round(decimales)
+        except:
+            pass
+    return df
+
+def calcular_promedio_desviacion(df, n_replicas, unidad_medida):
+    df = df.copy()
+    # Obtener las columnas de réplicas
+    col_replicas = [f"Concentración Real {i} ({unidad_medida})" for i in range(1, n_replicas + 1)]
+    # Convertir a numérico
+    for col in col_replicas:
+        df[col] = pd.to_numeric(df[col], errors='coerce')
+
+    # Calcular el promedio y la desviación estándar
+    df[f"Concentración Real Promedio ({unidad_medida})"] = df[col_replicas].mean(axis=1)
+
+    if n_replicas > 1:
+        df[f"Desviación Estándar ({unidad_medida})"] = df[col_replicas].std(ddof=1, axis=1)
+    else:
+        df[f"Desviación Estándar ({unidad_medida})"] = 0.0
+
+    return df
+
+def 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):
+    col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+    col_desviacion = f"Desviación Estándar ({unidad_medida})"
+
+    # Convertir a numérico
+    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['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
+
+    # Configurar estilos
+    sns.set(style="whitegrid")
+    plt.rcParams.update({'figure.autolayout': True})
+
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
+
+    # Obtener colores de las paletas
+    colors_puntos = sns.color_palette(palette_puntos, as_cmap=False)
+    colors_linea_ajuste = sns.color_palette(palette_linea_ajuste, as_cmap=False)
+    colors_linea_ideal = sns.color_palette(palette_linea_ideal, as_cmap=False)
+    colors_barras_error = sns.color_palette(palette_barras_error, as_cmap=False)
+
+    # Seleccionar colores
+    color_puntos = colors_puntos[0]
+    color_linea_ajuste = colors_linea_ajuste[0]
+    color_linea_ideal = colors_linea_ideal[0]
+    color_barras_error = colors_barras_error[0]
+
+    # Gráfico de dispersión con línea de regresión
+    if mostrar_puntos:
+        if n_replicas > 1:
+            # Incluir barras de error
+            ax1.errorbar(
+                df_valid[col_predicha_num],
+                df_valid[col_real_promedio],
+                yerr=df_valid[col_desviacion],
+                fmt=estilo_puntos,
+                color=color_puntos,
+                ecolor=color_barras_error,
+                elinewidth=2,
+                capsize=3,
+                label='Datos Reales'
+            )
+        else:
+            ax1.scatter(
+                df_valid[col_predicha_num],
+                df_valid[col_real_promedio],
+                color=color_puntos,
+                s=100,
+                label='Datos Reales',
+                marker=estilo_puntos
+            )
+
+    # Línea de ajuste
+    if mostrar_linea_ajuste:
+        ax1.plot(
+            df_valid[col_predicha_num],
+            df_valid['Ajuste Lineal'],
+            color=color_linea_ajuste,
+            label='Ajuste Lineal',
+            linewidth=2,
+            linestyle=estilo_linea_ajuste
+        )
 
-class YourModel(BaseModel):
-    class Config:
-        arbitrary_types_allowed = True
+    # Línea ideal
+    if mostrar_linea_ideal:
+        min_predicha = df_valid[col_predicha_num].min()
+        max_predicha = df_valid[col_predicha_num].max()
+        ax1.plot(
+            [min_predicha, max_predicha],
+            [min_predicha, max_predicha],
+            color=color_linea_ideal,
+            linestyle=estilo_linea_ideal,
+            label='Ideal'
+        )
 
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-import seaborn as sns
-from scipy.optimize import curve_fit
-from sklearn.metrics import mean_squared_error
-import gradio as gr
-import io
-from PIL import Image
-
-# Definición de la clase CalibrationModel
-class CalibrationModel:
-    def __init__(self):
-        self.params = {}
-        self.r2 = {}
-        self.rmse = {}
-        self.datax = []
-        self.datay = []
-        self.dataxp = []
-        self.datayp = []
-        self.datax_std = []
-        self.datay_std = []
-
-    # Función de ajuste lineal
-    @staticmethod
-    def linear(x, m, b):
-        return m * x + b
-
-    # Métodos de procesamiento y ajuste de datos
-    def process_data(self, df):
-        # Obtener todas las columnas que contengan "Concentración" y "Absorbancia"
-        concentration_cols = [col for col in df.columns if col[1] == 'Concentración']
-        absorbance_cols = [col for col in df.columns if col[1] == 'Absorbancia']
-
-        # Procesar los datos de concentración
-        data_concentration = [df[col].values for col in concentration_cols]
-        data_concentration = np.array(data_concentration)  # shape (num_experiments, num_time_points)
-        self.datax.append(data_concentration)
-        self.dataxp.append(np.mean(data_concentration, axis=0))
-        self.datax_std.append(np.std(data_concentration, axis=0, ddof=1))
-
-        # Procesar los datos de absorbancia
-        data_absorbance = [df[col].values for col in absorbance_cols]
-        data_absorbance = np.array(data_absorbance)
-        self.datay.append(data_absorbance)
-        self.datayp.append(np.mean(data_absorbance, axis=0))
-        self.datay_std.append(np.std(data_absorbance, axis=0, ddof=1))
-
-    def fit_model(self):
-        self.fit_calibration = self.fit_calibration_linear
-
-    def fit_calibration_linear(self, concentration, absorbance, bounds):
-        # Eliminar valores NaN e inf
-        mask = ~np.isnan(concentration) & ~np.isnan(absorbance) & np.isfinite(concentration) & np.isfinite(absorbance)
-        concentration = concentration[mask]
-        absorbance = absorbance[mask]
-
-        if len(concentration) == 0 or len(absorbance) == 0:
-            raise ValueError("No valid data points for fitting.")
-
-        popt, _ = curve_fit(self.linear, concentration, absorbance, bounds=bounds, maxfev=10000)
-        self.params['calibration'] = {'m': popt[0], 'b': popt[1]}
-        y_pred = self.linear(concentration, *popt)
-        self.r2['calibration'] = 1 - (np.sum((absorbance - y_pred) ** 2) / np.sum((absorbance - np.mean(absorbance)) ** 2))
-        self.rmse['calibration'] = np.sqrt(mean_squared_error(absorbance, y_pred))
-        return y_pred
-
-    # Métodos de visualización de resultados
-    def plot_results(self, concentration, absorbance, y_pred,
-                     concentration_std=None, absorbance_std=None,
-                     experiment_name='', legend_position='best', params_position='upper right',
-                     show_legend=True, show_params=True,
-                     style='whitegrid',
-                     line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o'):
-        sns.set_style(style)  # Establecer el estilo seleccionado
-
-        fig, ax = plt.subplots(figsize=(10, 7))
-        fig.suptitle(f'{experiment_name}', fontsize=16)
-
-        if absorbance_std is not None:
-            ax.errorbar(concentration, absorbance, yerr=absorbance_std, fmt=marker_style, color=point_color,
-                        label='Datos experimentales', capsize=5)
+    ax1.set_title('Correlación entre Concentración Predicha y Real', fontsize=14)
+    ax1.set_xlabel('Concentración Predicha', fontsize=12)
+    ax1.set_ylabel('Concentración Real Promedio', fontsize=12)
+
+    # Añadir ecuación y R² en el gráfico
+    ax1.annotate(
+        f'y = {intercept:.2f} + {slope:.2f}x\n$R^2$ = {r_value**2:.4f}',
+        xy=(0.05, 0.95),
+        xycoords='axes fraction',
+        fontsize=12,
+        backgroundcolor='white',
+        verticalalignment='top'
+    )
+
+    # Posicionar la leyenda
+    ax1.legend(loc='lower right', fontsize=10)
+
+    # Gráfico de residuos
+    residuos = df_valid[col_real_promedio] - df_valid['Ajuste Lineal']
+    ax2.scatter(
+        df_valid[col_predicha_num],
+        residuos,
+        color=color_puntos,
+        s=100,
+        marker=estilo_puntos,
+        label='Residuos'
+    )
+
+    ax2.axhline(y=0, color='black', linestyle='--', linewidth=1)
+    ax2.set_title('Gráfico de Residuos', fontsize=14)
+    ax2.set_xlabel('Concentración Predicha', fontsize=12)
+    ax2.set_ylabel('Residuo', fontsize=12)
+    ax2.legend(loc='upper right', fontsize=10)
+
+    plt.tight_layout()
+    plt.savefig('grafico.png')  # Guardar el gráfico para incluirlo en el informe
+    return fig
+
+def evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv_percent):
+    """Evaluar la calidad de la calibración y proporcionar recomendaciones"""
+    evaluacion = {
+        "calidad": "",
+        "recomendaciones": [],
+        "estado": "✅" if r_squared >= 0.95 and cv_percent <= 15 else "⚠️"
+    }
+
+    if r_squared >= 0.95:
+        evaluacion["calidad"] = "Excelente"
+    elif r_squared >= 0.90:
+        evaluacion["calidad"] = "Buena"
+    elif r_squared >= 0.85:
+        evaluacion["calidad"] = "Regular"
+    else:
+        evaluacion["calidad"] = "Deficiente"
+
+    if r_squared < 0.95:
+        evaluacion["recomendaciones"].append("- Considere repetir algunas mediciones para mejorar la correlación")
+
+    if cv_percent > 15:
+        evaluacion["recomendaciones"].append("- La variabilidad es alta. Revise el procedimiento de dilución")
+
+    if rmse > 0.1 * df_valid[df_valid.columns[-1]].astype(float).mean():
+        evaluacion["recomendaciones"].append("- El error de predicción es significativo. Verifique la técnica de medición")
+
+    return evaluacion
+
+def generar_informe_completo(df_valid, n_replicas, unidad_medida):
+    """Generar un informe completo en formato markdown"""
+    col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+
+    # Convertir a numérico
+    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])
+    r_squared = r_value ** 2
+    rmse = np.sqrt(((df_valid[col_real_promedio] - (intercept + slope * df_valid[col_predicha_num])) ** 2).mean())
+    cv = (df_valid[col_real_promedio].std() / df_valid[col_real_promedio].mean()) * 100  # CV de los valores reales
+
+    # Evaluar calidad
+    evaluacion = evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv)
+
+    informe = f"""# Informe de Calibración {evaluacion['estado']}
+Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}
+
+## Resumen Estadístico
+- **Ecuación de Regresión**: y = {intercept:.4f} + {slope:.4f}x
+- **Coeficiente de correlación (r)**: {r_value:.4f}
+- **Coeficiente de determinación ($R^2$)**: {r_squared:.4f}
+- **Valor p**: {p_value:.4e}
+- **Error estándar de la pendiente**: {std_err:.4f}
+- **Error cuadrático medio (RMSE)**: {rmse:.4f}
+- **Coeficiente de variación (CV)**: {cv:.2f}%
+
+## Evaluación de Calidad
+- **Calidad de la calibración**: {evaluacion['calidad']}
+
+## Recomendaciones
+{chr(10).join(evaluacion['recomendaciones']) if evaluacion['recomendaciones'] else "No hay recomendaciones específicas. La calibración cumple con los criterios de calidad."}
+
+## Decisión
+{("✅ APROBADO - La calibración cumple con los criterios de calidad establecidos" if evaluacion['estado'] == "✅" else "⚠️ REQUIERE REVISIÓN - La calibración necesita ajustes según las recomendaciones anteriores")}
+
+---
+*Nota: Este informe fue generado automáticamente. Por favor, revise los resultados y valide según sus criterios específicos.*
+"""
+    return informe, evaluacion['estado']
+
+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]
+
+    # 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)
+
+    return estado, fig, informe, df
+
+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):
+    if df is None or df.empty:
+        return None
+
+    # Asegurarse de que los cálculos estén actualizados
+    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 None
+
+    # Generar gráfico con opciones seleccionadas
+    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
+    )
+
+    return fig
+
+def exportar_informe_word(df_valid, informe_md, unidad_medida):
+    # Crear documento Word
+    doc = docx.Document()
+
+    # Estilos APA 7
+    style = doc.styles['Normal']
+    font = style.font
+    font.name = 'Times New Roman'
+    font.size = Pt(12)
+
+    # Título centrado
+    titulo = doc.add_heading('Informe de Calibración', 0)
+    titulo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+    # Fecha
+    fecha = doc.add_paragraph(f"Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}")
+    fecha.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+    # Insertar gráfico
+    if os.path.exists('grafico.png'):
+        doc.add_picture('grafico.png', width=Inches(6))
+        ultimo_parrafo = doc.paragraphs[-1]
+        ultimo_parrafo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+        # Leyenda del gráfico en estilo APA 7
+        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']
+
+    # Agregar contenido del informe
+    doc.add_heading('Resumen Estadístico', level=1)
+    for linea in informe_md.split('\n'):
+        if linea.startswith('##'):
+            doc.add_heading(linea.replace('##', '').strip(), level=2)
         else:
-            ax.plot(concentration, absorbance, marker=marker_style, linestyle='', color=point_color,
-                    label='Datos experimentales')
-        ax.plot(concentration, y_pred, linestyle=line_style, color=line_color, label='Modelo')
-        ax.set_xlabel('Concentración')
-        ax.set_ylabel('Absorbancia')
-        if show_legend:
-            ax.legend(loc=legend_position)
-        ax.set_title(f'Curva de Calibrado')
-
-        if show_params:
-            param_text = '\n'.join([f"{k} = {v:.4f}" for k, v in self.params['calibration'].items()])
-            text = f"{param_text}\nR² = {self.r2['calibration']:.4f}\nRMSE = {self.rmse['calibration']:.4f}"
-
-            # Si la posición es 'outside right', ajustar la posición del texto
-            if params_position == 'outside right':
-                bbox_props = dict(boxstyle='round', facecolor='white', alpha=0.5)
-                ax.annotate(text, xy=(1.05, 0.5), xycoords='axes fraction',
-                            verticalalignment='center', bbox=bbox_props)
-            else:
-                if params_position in ['upper right', 'lower right']:
-                    text_x = 0.95
-                    ha = 'right'
-                else:
-                    text_x = 0.05
-                    ha = 'left'
-
-                if params_position in ['upper right', 'upper left']:
-                    text_y = 0.95
-                    va = 'top'
-                else:
-                    text_y = 0.05
-                    va = 'bottom'
-
-                ax.text(text_x, text_y, text, transform=ax.transAxes,
-                        verticalalignment=va, horizontalalignment=ha,
-                        bbox={'boxstyle': 'round', 'facecolor': 'white', 'alpha': 0.5})
-
-        plt.tight_layout()
-        return fig
-
-# Función de procesamiento de datos
-def process_data(file, legend_position, params_position, experiment_names, lower_bounds, upper_bounds,
-                 style='whitegrid', line_color='#0000FF', point_color='#000000',
-                 line_style='-', marker_style='o', show_legend=True, show_params=True):
-    # Leer todas las hojas del archivo Excel
-    xls = pd.ExcelFile(file.name)
-    sheet_names = xls.sheet_names
-
-    model = CalibrationModel()
-    model.fit_model()
-    figures = []
-
-    # Si no se proporcionan suficientes límites, usar valores predeterminados
-    default_lower_bounds = (0, 0)
-    default_upper_bounds = (np.inf, np.inf)
-
-    experiment_counter = 0  # Contador global de experimentos
-
-    for sheet_name in sheet_names:
-        df = pd.read_excel(file.name, sheet_name=sheet_name, header=[0, 1])
-
-        # Procesar datos
-        model.process_data(df)
-        concentration = model.dataxp[-1]
-        absorbance = model.datayp[-1]
-
-        # Si hay replicados en el experimento, calcular la desviación estándar
-        concentration_std = None
-        absorbance_std = None
-        if concentration.ndim > 1:
-            concentration_std = np.std(concentration, axis=0, ddof=1)
-            concentration = np.mean(concentration, axis=0)
-        if absorbance.ndim > 1:
-            absorbance_std = np.std(absorbance, axis=0, ddof=1)
-            absorbance = np.mean(absorbance, axis=0)
-
-        # Obtener límites o usar valores predeterminados
-        lower_bound = lower_bounds[experiment_counter] if experiment_counter < len(lower_bounds) else default_lower_bounds
-        upper_bound = upper_bounds[experiment_counter] if experiment_counter < len(upper_bounds) else default_upper_bounds
-        bounds = (lower_bound, upper_bound)
-
-        # Ajustar el modelo
-        y_pred = model.fit_calibration(concentration, absorbance, bounds)
-
-        # Usar el nombre del experimento proporcionado o un nombre por defecto
-        experiment_name = experiment_names[experiment_counter] if experiment_counter < len(experiment_names) else f"Tratamiento {experiment_counter + 1}"
-
-        fig = model.plot_results(concentration, absorbance, y_pred,
-                                 concentration_std, absorbance_std,
-                                 experiment_name, legend_position, params_position,
-                                 show_legend, show_params,
-                                 style,
-                                 line_color, point_color, line_style, marker_style)
-        figures.append(fig)
-
-        experiment_counter += 1
-
-    return figures
-
-def create_interface():
-    with gr.Blocks(theme='upsatwal/mlsc_tiet') as demo:
-        gr.Markdown("# Ajuste de Curva de Calibrado")
-        gr.Markdown(
-            "Sube un archivo Excel con múltiples pestañas. Cada pestaña debe contener columnas 'Concentración' y 'Absorbancia' para cada experimento.")
-
-        file_input = gr.File(label="Subir archivo Excel")
+            doc.add_paragraph(linea)
+
+    # Añadir tabla de datos
+    doc.add_heading('Tabla de Datos de Calibración', level=1)
+
+    # Convertir DataFrame a lista de listas
+    tabla_datos = df_valid.reset_index(drop=True)
+    tabla_datos = tabla_datos.round(4)  # Redondear a 4 decimales si es necesario
+    columnas = tabla_datos.columns.tolist()
+    registros = tabla_datos.values.tolist()
+
+    # Crear tabla en Word
+    tabla = doc.add_table(rows=1 + len(registros), cols=len(columnas))
+    tabla.style = 'Table Grid'
+
+    # Añadir los encabezados
+    hdr_cells = tabla.rows[0].cells
+    for idx, col_name in enumerate(columnas):
+        hdr_cells[idx].text = col_name
+
+    # Añadir los registros
+    for i, registro in enumerate(registros):
+        row_cells = tabla.rows[i + 1].cells
+        for j, valor in enumerate(registro):
+            row_cells[j].text = str(valor)
+
+    # Formatear fuente de la tabla
+    for row in tabla.rows:
+        for cell in row.cells:
+            for paragraph in cell.paragraphs:
+                paragraph.style = doc.styles['Normal']
+
+    # Guardar documento
+    filename = 'informe_calibracion.docx'
+    doc.save(filename)
+    return filename
+
+def exportar_informe_latex(df_valid, informe_md):
+    # Generar código LaTeX
+    informe_tex = r"""\documentclass{article}
+\usepackage[spanish]{babel}
+\usepackage{amsmath}
+\usepackage{graphicx}
+\usepackage{booktabs}
+\begin{document}
+"""
+    informe_tex += informe_md.replace('#', '').replace('**', '\\textbf{').replace('*', '\\textit{')
+    informe_tex += r"""
+\end{document}
+"""
+    filename = 'informe_calibracion.tex'
+    with open(filename, 'w') as f:
+        f.write(informe_tex)
+    return filename
+
+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[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])
+
+    if df_valid.empty:
+        return None
+
+    filename = exportar_informe_word(df_valid, informe_md, unidad_medida)
+
+    return filename  # Retornamos el nombre del archivo
+
+def exportar_latex(df, informe_md):
+    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]
+
+    # Convertir columnas a numérico
+    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])
+
+    if df_valid.empty:
+        return None
+
+    filename = exportar_informe_latex(df_valid, informe_md)
+
+    return filename  # Retornamos el nombre del archivo
+
+# Funciones de ejemplo
+def cargar_ejemplo_ufc(n_replicas):
+    df = generar_tabla(7, 2000000, "UFC", n_replicas)
+    # Valores reales de ejemplo
+    for i in range(1, n_replicas + 1):
+        valores_reales = [2000000 - (i - 1) * 10000, 1600000 - (i - 1) * 8000, 1200000 - (i - 1) * 6000,
+                          800000 - (i - 1) * 4000, 400000 - (i - 1) * 2000, 200000 - (i - 1) * 1000,
+                          100000 - (i - 1) * 500]
+        df[f"Concentración Real {i} (UFC)"] = valores_reales
+    return 2000000, "UFC", 7, df
+
+def cargar_ejemplo_od(n_replicas):
+    df = generar_tabla(7, 1.0, "OD", n_replicas)
+    # Valores reales de ejemplo
+    for i in range(1, n_replicas + 1):
+        valores_reales = [1.00 - (i - 1) * 0.05, 0.80 - (i - 1) * 0.04, 0.60 - (i - 1) * 0.03,
+                          0.40 - (i - 1) * 0.02, 0.20 - (i - 1) * 0.01, 0.10 - (i - 1) * 0.005,
+                          0.05 - (i - 1) * 0.002]
+        df[f"Concentración Real {i} (OD)"] = valores_reales
+    return 1.0, "OD", 7, df
+
+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[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[col_real] = datos_sinteticos
+
+    return df
+
+def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas):
+    # Actualizar tabla sin borrar "Concentración Real"
+    df_new = generar_tabla(n_filas, concentracion, unidad, n_replicas)
+
+    # Mapear columnas
+    col_real_new = [col for col in df_new.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col]
+    col_real_old = [col for col in df.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col]
+
+    # Reemplazar valores existentes en "Concentración Real"
+    for col_new, col_old in zip(col_real_new, col_real_old):
+        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]
+
+    return df_new
+
+def cargar_excel(file):
+    # Leer el archivo Excel
+    df = pd.read_excel(file.name, sheet_name=None)
+
+    # Verificar que el archivo tenga al menos dos pestañas
+    if len(df) < 2:
+        return "El archivo debe tener al menos dos pestañas.", None, None, None, None, None, None
+
+    # Obtener la primera pestaña como referencia
+    primera_pestaña = next(iter(df.values()))
+    concentracion_inicial = primera_pestaña.iloc[0, 0]
+    unidad_medida = primera_pestaña.columns[0].split('(')[-1].split(')')[0]
+    n_filas = len(primera_pestaña)
+    n_replicas = len(df)
+
+    # Generar la tabla base
+    df_base = generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas)
+
+    # Llenar la tabla con los datos de cada pestaña
+    for i, (sheet_name, sheet_df) in enumerate(df.items(), start=1):
+        col_real = f"Concentración Real {i} ({unidad_medida})"
+        df_base[col_real] = sheet_df.iloc[:, 1].values
+
+    return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_base, "", None, ""
+
+# Interfaz Gradio
+with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
+    gr.Markdown("""
+    # 📊 Sistema Avanzado de Calibración con Análisis Estadístico
+    Configure los parámetros, edite los valores en la tabla y luego presione "Calcular" para obtener el análisis.
+    """)
+
+    with gr.Tab("📝 Datos de Calibración"):
+        with gr.Row():
+            concentracion_input = gr.Number(
+                value=2000000,
+                label="Concentración Inicial",
+                precision=0
+            )
+            unidad_input = gr.Textbox(
+                value="UFC",
+                label="Unidad de Medida",
+                placeholder="UFC, OD, etc..."
+            )
+            filas_slider = gr.Slider(
+                minimum=1,
+                maximum=20,
+                value=7,
+                step=1,
+                label="Número de filas"
+            )
+            decimales_slider = gr.Slider(
+                minimum=0,
+                maximum=5,
+                value=0,
+                step=1,
+                label="Número de Decimales"
+            )
+            replicas_slider = gr.Slider(
+                minimum=1,
+                maximum=10,
+                value=1,
+                step=1,
+                label="Número de Réplicas"
+            )
 
         with gr.Row():
-            with gr.Column():
-                legend_position = gr.Radio(
-                    choices=["upper left", "upper right", "lower left", "lower right", "best"],
-                    label="Posición de la leyenda",
-                    value="best"
-                )
-                show_legend = gr.Checkbox(label="Mostrar Leyenda", value=True)
-
-            with gr.Column():
-                params_positions = ["upper left", "upper right", "lower left", "lower right", "outside right"]
-                params_position = gr.Radio(
-                    choices=params_positions,
-                    label="Posición de los parámetros",
-                    value="upper right"
-                )
-                show_params = gr.Checkbox(label="Mostrar Parámetros", value=True)
-
-        experiment_names = gr.Textbox(
-            label="Nombres de los experimentos (uno por línea)",
-            placeholder="Experimento 1\nExperimento 2\n...",
-            lines=5
+            calcular_btn = gr.Button("🔄 Calcular", variant="primary")
+            limpiar_btn = gr.Button("🗑 Limpiar Datos", variant="secondary")
+            ajustar_decimales_btn = gr.Button("🛠 Ajustar Decimales", 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")
+            cargar_excel_btn = gr.UploadButton("📂 Cargar Excel", file_types=[".xlsx"], variant="secondary")
+
+        tabla_output = gr.DataFrame(
+            wrap=True,
+            label="Tabla de Datos",
+            interactive=True,
+            type="pandas",
         )
 
+    with gr.Tab("📊 Análisis y Reporte"):
+        estado_output = gr.Textbox(label="Estado", interactive=False)
+        graficos_output = gr.Plot(label="Gráficos de Análisis")
+
+        # Opciones y botones debajo del gráfico
+        with gr.Row():
+            # Paletas de colores disponibles en Seaborn
+            paletas_colores = ["deep", "muted", "pastel", "bright", "dark", "colorblind", "Set1", "Set2", "Set3"]
+
+            palette_puntos_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="deep",
+                label="Paleta para Puntos"
+            )
+            estilo_puntos_dropdown = gr.Dropdown(
+                choices=["o", "s", "^", "D", "v", "<", ">", "h", "H", "p", "*", "X", "d"],
+                value="o",
+                label="Estilo de Puntos"
+            )
+            palette_linea_ajuste_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="muted",
+                label="Paleta Línea de Ajuste"
+            )
+            estilo_linea_ajuste_dropdown = gr.Dropdown(
+                choices=["-", "--", "-.", ":"],
+                value="-",
+                label="Estilo Línea de Ajuste"
+            )
+
+        with gr.Row():
+            palette_linea_ideal_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="bright",
+                label="Paleta Línea Ideal"
+            )
+            estilo_linea_ideal_dropdown = gr.Dropdown(
+                choices=["--", "-", "-.", ":"],
+                value="--",
+                label="Estilo Línea Ideal"
+            )
+            palette_barras_error_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="pastel",
+                label="Paleta Barras de Error"
+            )
+            mostrar_linea_ajuste = gr.Checkbox(value=True, label="Mostrar Línea de Ajuste")
+            mostrar_linea_ideal = gr.Checkbox(value=True, label="Mostrar Línea Ideal")
+            mostrar_puntos = gr.Checkbox(value=True, label="Mostrar Puntos")
+            graficar_btn = gr.Button("📊 Graficar", variant="primary")
+
+        with gr.Row():
+            copiar_btn = gr.Button("📋 Copiar Informe", variant="secondary")
+            exportar_word_btn = gr.Button("💾 Exportar Informe Word", variant="primary")
+            exportar_latex_btn = gr.Button("💾 Exportar Informe LaTeX", variant="primary")
+
         with gr.Row():
-            with gr.Column():
-                lower_bounds = gr.Textbox(
-                    label="Lower Bounds (uno por línea, formato: m,b)",
-                    placeholder="0,0\n0,0\n...",
-                    lines=5
-                )
-
-            with gr.Column():
-                upper_bounds = gr.Textbox(
-                    label="Upper Bounds (uno por línea, formato: m,b)",
-                    placeholder="inf,inf\ninf,inf\n...",
-                    lines=5
-                )
-
-        # Añadir un desplegable para seleccionar el estilo del gráfico
-        styles = ['white', 'dark', 'whitegrid', 'darkgrid', 'ticks']
-        style_dropdown = gr.Dropdown(choices=styles, label="Selecciona el estilo de gráfico", value='whitegrid')
-
-        # Añadir color pickers para líneas y puntos
-        line_color_picker = gr.ColorPicker(label="Color de la línea", value='#0000FF')
-        point_color_picker = gr.ColorPicker(label="Color de los puntos", value='#000000')
-
-        # Añadir listas desplegables para tipo de línea y tipo de punto
-        line_style_options = ['-', '--', '-.', ':']
-        line_style_dropdown = gr.Dropdown(choices=line_style_options, label="Estilo de línea", value='-')
-
-        marker_style_options = ['o', 's', '^', 'v', 'D', 'x', '+', '*']
-        marker_style_dropdown = gr.Dropdown(choices=marker_style_options, label="Estilo de punto", value='o')
-
-        simulate_btn = gr.Button("Simular")
-
-        # Definir un componente gr.Gallery para las salidas
-        output_gallery = gr.Gallery(label="Resultados", columns=2, height='auto')
-
-        def process_and_plot(file, legend_position, params_position, experiment_names,
-                             lower_bounds, upper_bounds, style,
-                             line_color, point_color, line_style, marker_style,
-                             show_legend, show_params):
-            # Dividir los nombres de experimentos y límites en listas
-            experiment_names_list = experiment_names.strip().split('\n') if experiment_names.strip() else []
-            lower_bounds_list = [tuple(map(float, lb.split(','))) for lb in
-                                 lower_bounds.strip().split('\n')] if lower_bounds.strip() else []
-            upper_bounds_list = [tuple(map(float, ub.split(','))) for ub in
-                                 upper_bounds.strip().split('\n')] if upper_bounds.strip() else []
-
-            # Procesar los datos y generar gráficos
-            figures = process_data(file, legend_position, params_position, experiment_names_list,
-                                   lower_bounds_list, upper_bounds_list, style,
-                                   line_color, point_color, line_style, marker_style,
-                                   show_legend, show_params)
-
-            # Convertir las figuras a imágenes y devolverlas como lista
-            image_list = []
-            for fig in figures:
-                buf = io.BytesIO()
-                fig.savefig(buf, format='png')
-                buf.seek(0)
-                image = Image.open(buf)
-                image_list.append(image)
-
-            return image_list
-
-        simulate_btn.click(
-            fn=process_and_plot,
-            inputs=[file_input,
-                    legend_position,
-                    params_position,
-                    experiment_names,
-                    lower_bounds,
-                    upper_bounds,
-                    style_dropdown,
-                    line_color_picker,
-                    point_color_picker,
-                    line_style_dropdown,
-                    marker_style_dropdown,
-                    show_legend,
-                    show_params],
-            outputs=output_gallery
+            exportar_word_file = gr.File(label="Informe en Word")
+            exportar_latex_file = gr.File(label="Informe en LaTeX")
+
+        # Informe al final
+        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=output_components
+    )
+
+    # Evento para graficar con opciones seleccionadas
+    graficar_btn.click(
+        fn=actualizar_graficos,
+        inputs=[
+            tabla_output, replicas_slider, unidad_input,
+            palette_puntos_dropdown, estilo_puntos_dropdown,
+            palette_linea_ajuste_dropdown, estilo_linea_ajuste_dropdown,
+            palette_linea_ideal_dropdown, estilo_linea_ideal_dropdown,
+            palette_barras_error_dropdown,
+            mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos
+        ],
+        outputs=graficos_output
+    )
+
+    # Evento para limpiar datos
+    limpiar_btn.click(
+        fn=limpiar_datos,
+        inputs=[replicas_slider],
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
+    )
+
+    # 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]
+    )
+
+    ejemplo_od_btn.click(
+        fn=cargar_ejemplo_od,
+        inputs=[replicas_slider],
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output]
+    )
+
+    # Evento para generar datos sintéticos
+    sinteticos_btn.click(
+        fn=generar_datos_sinteticos_evento,
+        inputs=[tabla_output, replicas_slider, unidad_input],
+        outputs=tabla_output
+    )
+
+    # Evento para cargar archivo Excel
+    cargar_excel_btn.upload(
+        fn=cargar_excel,
+        inputs=[cargar_excel_btn],
+        outputs=[concentracion_input, unidad_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output]
+    )
+
+    # Evento al presionar el botón Ajustar Decimales
+    ajustar_decimales_btn.click(
+        fn=ajustar_decimales_evento,
+        inputs=[tabla_output, decimales_slider],
+        outputs=tabla_output
+    )
+
+    # Actualizar tabla al cambiar los parámetros (sin borrar "Concentración Real")
+    def actualizar_tabla_wrapper(df, filas, conc, unidad, replicas):
+        return actualizar_tabla_evento(df, filas, conc, unidad, replicas)
+
+    concentracion_input.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
+        outputs=tabla_output
+    )
+
+    unidad_input.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
+        outputs=tabla_output
+    )
+
+    filas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
+        outputs=tabla_output
+    )
+
+    replicas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
+        outputs=tabla_output
+    )
+
+    # No agregamos un evento para decimales_slider.change, para evitar borrar la columna "Concentración Real"
+
+    # Evento de copiar informe utilizando JavaScript
+    copiar_btn.click(
+        None,
+        [],
+        [],
+        js="""
+        function() {
+            const informeElement = document.querySelector('#informe_output');
+            const range = document.createRange();
+            range.selectNode(informeElement);
+            window.getSelection().removeAllRanges();
+            window.getSelection().addRange(range);
+            document.execCommand('copy');
+            window.getSelection().removeAllRanges();
+            alert('Informe copiado al portapapeles');
+        }
+        """
+    )
+
+    # Eventos de exportar informes
+    exportar_word_btn.click(
+        fn=exportar_word,
+        inputs=[tabla_output, informe_output, unidad_input],
+        outputs=exportar_word_file
+    )
+
+    exportar_latex_btn.click(
+        fn=exportar_latex,
+        inputs=[tabla_output, informe_output],
+        outputs=exportar_latex_file
+    )
+
+    # Inicializar la interfaz con el ejemplo base
+    def iniciar_con_ejemplo():
+        n_replicas = 1
+        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")
+        return (
+            2000000,
+            "UFC",
+            7,
+            df,
+            estado,
+            fig,
+            informe
         )
 
-    return demo
+    interfaz.load(
+        fn=iniciar_con_ejemplo,
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
+    )
 
-# Crear y lanzar la interfaz
-demo = create_interface()
-demo.launch(share=True)
+# Lanzar la interfaz
+if __name__ == "__main__":
+    interfaz.launch()