app.py

"""
CÓDIGO COMPLETO Y CORREGIDO - VERSIÓN 7.8 (Agente de Instrucciones de Lenguaje Natural)
- MEJORA MAYOR: Se ha creado un nuevo `InstructionParsingAgent` que interpreta las instrucciones
  en lenguaje natural del usuario desde el cuadro de "Especificaciones Adicionales".
- FUNCIONALIDAD AVANZADA: El usuario puede especificar qué métricas usar (R2, RMSE, o ambas) y
  cuántos "Top N" modelos seleccionar, simplemente escribiéndolo.
- MODELSELECTIONAGENT MEJORADO: La lógica del "Plan B" ahora es dinámica y se basa en las
  instrucciones parseadas, calculando un score combinado si se especifican múltiples métricas.
- UI SIMPLIFICADA: Se han eliminado los controles estáticos de ranking, reemplazados por el
  cuadro de texto de instrucciones, haciendo la interfaz más limpia y potente.
"""

import gradio as gr
from gradio_client import Client, handle_file
import pandas as pd
import json
import tempfile
import os
import re
from datetime import datetime
import plotly.graph_objects as go
import logging
import numpy as np
from smolagents import CodeAgent, InferenceClientModel

# --- CONFIGURACIÓN Y CLIENTES ---
logging.basicConfig(level=logging.INFO); logger = logging.getLogger(__name__)

# --- INICIALIZACIÓN DE MODELO PARA AGENTES ---
try:
    hf_engine = InferenceClientModel(model_id="deepseek-ai/DeepSeek-V2-Lite-Instruct")
    logger.info("✅ Modelo de lenguaje (DeepSeek-V2-Lite) inicializado para agentes.")
except Exception: hf_engine = None; logger.error("❌ No se pudo inicializar el modelo de lenguaje para agentes.")

try: biotech_client = Client("C2MV/BiotechU4"); logger.info("✅ Cliente BiotechU4 inicializado.")
except: biotech_client = None
try: analysis_client = Client("C2MV/Project-HF-2025-2"); logger.info("✅ Cliente Project-HF-2025-2 inicializado.")
except: analysis_client = None

# ============================================================================
# 🤖 SISTEMA DE AGENTES (LÓGICA ACTUALIZADA)
# ============================================================================

class LoggingAgent:
    def __init__(self): self.log_entries, self.start_time = [], datetime.now(); logger.info("🕵️ LoggingAgent activado.")
    def register(self, agent_name, action, details=""):
        entry = f"**{datetime.now().strftime('%H:%M:%S')} | {agent_name}:** {action}"; self.log_entries.append(entry + (f"\n> *Detalles: {details}*" if details else ""))
    def get_report(self):
        if not self.log_entries: return "### 🕵️ Informe de Actividad\n\nNo se registraron actividades."
        return "### 🕵️ Informe de Actividad de Agentes\n\n---\n\n" + "\n\n---\n\n".join(self.log_entries) + f"\n\n---\n\n**Tiempo total: {(datetime.now() - self.start_time).total_seconds():.2f} s.**"
    def clear(self): self.log_entries, self.start_time = [], datetime.now()


class StructureValidationAgent:
    def __init__(self, log_agent: LoggingAgent): self.log_agent = log_agent
    def validate(self, file_obj):
        try:
            if file_obj.name.endswith(('.xls', '.xlsx')): df = pd.read_excel(file_obj.name, header=1)
            else: df = pd.read_csv(file_obj.name)
            if df.empty: return False, "Validación fallida: El archivo está vacío."
        except Exception as e: return False, f"Error crítico al leer el archivo: {e}"
        self.log_agent.register("StructureValidationAgent", "Validación de formato de archivo superada.")
        return True, "Formato de archivo básico validado."


class InstructionParsingAgent:
    """Agente que convierte el lenguaje natural del usuario en un plan de acción estructurado."""
    def __init__(self, log_agent: LoggingAgent, llm_engine):
        self.log_agent = log_agent
        self.agent = CodeAgent(tools=[], model=llm_engine) if llm_engine else None

    def parse(self, text: str):
        default_instructions = {'metrics': ['R2'], 'top_n': 3}
        if not self.agent:
            self.log_agent.register("InstructionParsingAgent", "LLM no disponible, usando defaults.")
            return default_instructions

        prompt = f"""
        Analyze the user's instruction for a data analysis task. Extract the metrics they want to use for ranking and the number of top models to select.
        The possible metrics are "R2", "RMSE".
        Your output MUST be ONLY a valid JSON object with two keys: "metrics" (a list of strings) and "top_n" (an integer).

        - If the user mentions "R2" or "R-cuadrado", include "R2" in the metrics list.
        - If the user mentions "RMSE", include "RMSE" in the metrics list.
        - If the user mentions a number like "top 3", "los 2 mejores", or just a digit, set "top_n" to that number.
        - If no metrics are mentioned, default to ["R2"].
        - If no number is mentioned, default to 3.

        Example 1: "Usa el promedio de R2 y RMSE y elige el top 2" -> {{"metrics": ["R2", "RMSE"], "top_n": 2}}
        Example 2: "dame los 3 mejores modelos segun el menor RMSE" -> {{"metrics": ["RMSE"], "top_n": 3}}
        Example 3: "el mejor R2" -> {{"metrics": ["R2"], "top_n": 1}}
        Example 4: "analizar los datos" -> {{"metrics": ["R2"], "top_n": 3}}

        User instruction: "{text}"
        JSON Output:
        """
        try:
            response_str = self.agent.run(prompt)
            json_str = response_str[response_str.find('{'):response_str.rfind('}')+1]
            instructions = json.loads(json_str)
            # Validar que el formato es correcto
            if 'metrics' not in instructions or 'top_n' not in instructions:
                raise ValueError("JSON de salida no contiene las claves esperadas.")
            self.log_agent.register("InstructionParsingAgent", "Instrucciones del usuario parseadas con éxito.")
            return instructions
        except Exception as e:
            self.log_agent.register("InstructionParsingAgent", "Error parseando instrucciones, usando defaults.", f"Error: {e}")
            return default_instructions


class ModelSelectionAgent:
    """Agente 3 (CON FALLBACK CONFIGURABLE): Identifica los mejores modelos, con un plan B personalizable."""
    def __init__(self, log_agent: LoggingAgent): self.log_agent = log_agent

    def _find_column(self, df_columns, possible_names):
        for name in possible_names:
            for col in df_columns:
                if str(col).lower() == name.lower(): return col
        return None

    def identify_best_models(self, results_df, component, r2_threshold, rmse_threshold, instructions: dict):
        self.log_agent.register("ModelSelectionAgent", f"Iniciando identificación para: '{component}'.")
        
        # 1. Normalizar columna del Modelo
        model_col = self._find_column(results_df.columns, ['model', 'modelo'])
        if not model_col: return [], "Error: No se encontró la columna de nombres de modelos ('Model')."
        df_norm = results_df.rename(columns={model_col: 'Model'})

        # 2. Identificar columnas de métricas
        r2_target_col, rmse_target_col = None, None
        if component != 'all':
            r2_target_col = self._find_column(df_norm.columns, [f'r2_{component}'])
            rmse_target_col = self._find_column(df_norm.columns, [f'rmse_{component}'])
        else:
            metric_cols_r2 = [c for c in df_norm.columns if 'r2_' in str(c).lower()]
            metric_cols_rmse = [c for c in df_norm.columns if 'rmse_' in str(c).lower()]
            if metric_cols_r2 and metric_cols_rmse:
                r2_target_col, rmse_target_col = 'R2_Avg', 'RMSE_Avg'
                df_norm[r2_target_col] = df_norm[metric_cols_r2].mean(axis=1, skipna=True)
                df_norm[rmse_target_col] = df_norm[metric_cols_rmse].mean(axis=1, skipna=True)

        if not r2_target_col or not rmse_target_col or r2_target_col not in df_norm.columns or rmse_target_col not in df_norm.columns:
            return [], f"Error: No se encontraron las métricas para el componente '{component}'."

        # 3. Agrupar por modelo y calcular métrica de rendimiento promedio
        model_performance = df_norm.groupby('Model').agg({r2_target_col: 'mean', rmse_target_col: 'mean'}).reset_index()
        
        # 4. Intento 1: Filtrado Estricto
        good_models_df = model_performance[(model_performance[r2_target_col] >= r2_threshold) & (model_performance[rmse_target_col] <= rmse_threshold)]

        if not good_models_df.empty:
            best_models_list = sorted([str(model).lower() for model in good_models_df['Model'].tolist()])
            reasoning = f"Agente identificó **{len(best_models_list)}** modelo(s) que cumplen tus criterios: `{', '.join(best_models_list)}`."
            return best_models_list, reasoning
        else:
            # 5. Intento 2: Plan B - Ranking Estratégico basado en instrucciones
            self.log_agent.register("ModelSelectionAgent", "Filtro primario falló. Activando fallback: 'Ranking por Instrucciones'.", f"Plan: {instructions}")
            
            use_r2 = 'R2' in instructions['metrics']
            use_rmse = 'RMSE' in instructions['metrics']
            top_n = instructions['top_n']

            # Calcular el score de rendimiento
            if use_r2 and use_rmse:
                model_performance['Score'] = model_performance[r2_target_col] / (model_performance[rmse_target_col] + 1e-9)
                sort_col, ascending, metric_name = 'Score', False, "R²/RMSE combinado"
            elif use_rmse:
                sort_col, ascending, metric_name = rmse_target_col, True, "RMSE"
            else: # Por defecto R2
                sort_col, ascending, metric_name = r2_target_col, False, "R²"

            sorted_performance = model_performance.sort_values(by=sort_col, ascending=ascending)
            top_n_df = sorted_performance.head(top_n)
                
            best_models_list = sorted([str(model).lower() for model in top_n_df['Model'].tolist()])
            reasoning = (f"**Advertencia:** Ningún modelo cumplió con los criterios iniciales.\n\n"
                         f"Como plan B, el agente ha seleccionado los **Top {len(best_models_list)}** modelos con el mejor **{metric_name} promedio**: `{', '.join(best_models_list)}`.")
            return best_models_list, reasoning

# --- INICIALIZACIÓN DE AGENTES GLOBALES ---
log_agent = LoggingAgent(); validation_agent = StructureValidationAgent(log_agent)
instruction_parser_agent = InstructionParsingAgent(log_agent, hf_engine)
model_selection_agent = ModelSelectionAgent(log_agent)

# --- FUNCIONES DEL PIPELINE ---
def create_dummy_plot(title="Esperando resultados..."):
    fig = go.Figure(go.Scatter(x=[], y=[])); fig.update_layout(title=title, template="plotly_white", height=500, annotations=[dict(text="Sube un archivo y ejecuta", showarrow=False)])
    return fig

def detect_experiments(file_obj):
    if not file_obj: return gr.update(choices=[], value=[])
    try:
        df_first_row = pd.read_excel(file_obj.name, header=None, nrows=1)
        exp_names = [str(name).strip() for name in df_first_row.iloc[0].dropna().tolist()]
        return gr.update(choices=exp_names, value=exp_names, interactive=True)
    except Exception as e: return gr.update(choices=[], value=[], interactive=False, placeholder=f"Error: {e}")

# ... (ETAPA 1: run_base_analysis - sin cambios) ...
def run_base_analysis(file, models, exp_names_selected, component, use_de, maxfev, progress=gr.Progress()):
    log_agent.clear(); progress(0, desc="🚀 Iniciando Análisis Base...")
    if not file or not models or not exp_names_selected:
        return create_dummy_plot(), None, "❌ Por favor, sube un archivo y selecciona modelos/experimentos.", gr.update(interactive=False), {}, None, None, log_agent.get_report()
    log_agent.register("Pipeline (Etapa 1)", "Iniciando Análisis Base."); progress(0.2, desc="Validando archivo...")
    is_valid, msg = validation_agent.validate(file)
    if not is_valid: return create_dummy_plot(), None, msg, gr.update(interactive=False), {}, None, None, log_agent.get_report()
    progress(0.5, desc="Ejecutando análisis biotecnológico...");
    if not biotech_client: return create_dummy_plot(), None, "❌ Cliente BiotechU4 no disponible.", gr.update(interactive=False), {}, None, None, log_agent.get_report()
    try:
        exp_names_str = ",".join(exp_names_selected); models_lower = [str(m).lower() for m in models]
        plot_info, df_data, status = biotech_client.predict(file=handle_file(file.name), models=models_lower, component=component, use_de=use_de, maxfev=maxfev, exp_names=exp_names_str, api_name="/run_analysis_wrapper")
        if "Error" in status: raise Exception(status)
    except Exception as e:
        return create_dummy_plot(), None, f"❌ Error en Análisis Base: {e}", gr.update(interactive=False), {}, None, None, log_agent.get_report()
    progress(1, desc="🎉 Análisis Base Completado")
    final_status = "✅ Análisis Base completado. \n➡️ Ahora puedes aplicar el filtro de IA y generar el informe final."
    results_df_obj = {'data': df_data['data'], 'headers': df_data['headers']}
    fig = go.Figure(json.loads(plot_info['plot'])) if plot_info and 'plot' in plot_info else create_dummy_plot()
    original_params = {'exp_names': exp_names_selected, 'component': component, 'use_de': use_de, 'maxfev': maxfev}
    return fig, df_data, final_status, gr.update(interactive=True), results_df_obj, file.name, original_params, log_agent.get_report()

# --- ETAPA 2: REFINAMIENTO Y REPORTE IA (ACTUALIZADA) ---
def refine_and_generate_report(baseline_results, file_path, original_params, r2_threshold, rmse_threshold, instructions_text, ia_model, detail_level, language, max_output_tokens, use_personal_key, personal_api_key, progress=gr.Progress()):
    progress(0, desc="🚀 Iniciando Refinamiento con IA..."); log_agent.register("Pipeline (Etapa 2)", "Iniciando Refinamiento.")
    if not baseline_results or not file_path or not original_params:
        return gr.update(), None, None, None, "❌ No hay resultados base para refinar.", None, log_agent.get_report()
    
    progress(0.1, desc="Agente de Parseo interpretando instrucciones...")
    instructions = instruction_parser_agent.parse(instructions_text)
    log_agent.register("InstructionParsingAgent", "Instrucciones interpretadas.", f"Plan: {instructions}")

    progress(0.2, desc="Agente de Selección identificando mejores modelos...")
    results_df = pd.DataFrame(baseline_results['data'], columns=baseline_results['headers'])
    best_models, reasoning = model_selection_agent.identify_best_models(results_df, original_params['component'], r2_threshold, rmse_threshold, instructions)
    
    if not best_models:
        return gr.update(), baseline_results, None, None, f"🤖 Análisis del Agente:\n{reasoning}", None, log_agent.get_report()
    
    progress(0.4, desc="Re-ejecutando análisis con los mejores modelos...");
    try:
        exp_names_str = ",".join(original_params['exp_names'])
        final_plot_info, final_df_data, final_status = biotech_client.predict(file=handle_file(file_path), models=best_models, component=original_params['component'], use_de=original_params['use_de'], maxfev=original_params['maxfev'], exp_names=exp_names_str, api_name="/run_analysis_wrapper")
        if "Error" in final_status: raise Exception(final_status)
    except Exception as e:
        return gr.update(), None, None, None, f"❌ Error en el re-análisis final: {e}", None, log_agent.get_report()

    progress(0.6, desc="Generando informe IA..."); temp_csv_file = None
    try:
        final_results_df = pd.DataFrame(final_df_data['data'], columns=final_df_data['headers'])
        with tempfile.NamedTemporaryFile(mode='w+', suffix='.csv', delete=False, encoding='utf-8') as temp_f:
            final_results_df.to_csv(temp_f.name, index=False); temp_csv_file = temp_f.name
        current_analysis_client = analysis_client
        if use_personal_key and personal_api_key: current_analysis_client = Client("C2MV/Project-HF-2025-2", hf_token=personal_api_key)
        chunk_update_dict = current_analysis_client.predict(files=[handle_file(temp_csv_file)], api_name="/update_chunk_column_selector")
        selected_chunk_column = chunk_update_dict['choices'][0][0]
        result = current_analysis_client.predict(files=[handle_file(temp_csv_file)], chunk_column=selected_chunk_column, qwen_model=ia_model, detail_level=detail_level, language=language, additional_specs="", max_output_tokens=max_output_tokens, api_name="/process_files_and_analyze")
        _, analysis_report, implementation_code, token_usage = result
    except Exception as e:
        return gr.update(), final_df_data, None, None, f"❌ Error generando informe IA: {e}", None, log_agent.get_report()
    finally:
        if temp_csv_file and os.path.exists(temp_csv_file): os.remove(temp_csv_file)
        
    progress(0.9, desc="Finalizando..."); final_report_path = None
    if analysis_report:
        export_dir = "exported_reports"; os.makedirs(export_dir, exist_ok=True)
        final_report_path = os.path.join(export_dir, f"report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md")
        with open(final_report_path, 'w', encoding='utf-8') as f: f.write(analysis_report)
    
    final_status = f"✅ Refinamiento y reporte completados.\n{reasoning}\nInforme IA generado con {token_usage}."
    final_fig = go.Figure(json.loads(final_plot_info['plot'])) if final_plot_info and 'plot' in final_plot_info else create_dummy_plot()
    return final_fig, final_df_data, analysis_report, implementation_code, final_status, final_report_path, log_agent.get_report()

# ... (create_dummy_excel_file y constantes sin cambios) ...
def create_dummy_excel_file():
    examples_dir = "examples"; os.makedirs(examples_dir, exist_ok=True); file_path = os.path.join(examples_dir, "archivo.xlsx")
    if not os.path.exists(file_path):
        exp_names = ['CN 20_1', 'CN 20_2', 'CN 30_1', 'CN 40_1']; writer = pd.ExcelWriter(file_path, engine='xlsxwriter'); worksheet = writer.book.add_worksheet('Datos'); writer.sheets['Datos'] = worksheet
        for i, name in enumerate(exp_names): worksheet.write(0, i * 4, name)
        start_col = 0
        for _ in exp_names:
            time = np.arange(0, 11, 2); biomass = 0.2 + (np.random.rand() * 20) / (1 + np.exp(4 - 0.5 * time)) + np.random.rand(len(time)) * 0.2
            substrate = 10 * np.exp(-0.2 * time) + np.random.rand(len(time)) * 0.3; product = 1 * (1 - np.exp(-0.3 * time)) + np.random.rand(len(time)) * 0.1
            df = pd.DataFrame({'Tiempo': time, 'Biomasa': biomass, 'Sustrato': substrate, 'Producto': product})
            df.to_excel(writer, sheet_name='Datos', startrow=1, startcol=start_col, index=False); start_col += 4
        writer.close()

BIOTECH_MODELS = ['logistic', 'gompertz', 'moser', 'baranyi', 'monod', 'contois', 'andrews', 'tessier', 'richards', 'stannard', 'huang']
IA_MODELS = ["deepseek-ai/DeepSeek-V3-0324"]
theme = gr.themes.Soft(primary_hue="blue", secondary_hue="indigo", neutral_hue="slate")

if __name__ == "__main__":
    create_dummy_excel_file()
    with gr.Blocks(theme=theme, title="BioTech Analysis & Report Generator") as demo:
        gr.Markdown("# 🧬 BioTech Analysis & Report Generator v7.8")
        gr.Markdown("### Un pipeline inteligente de dos etapas: Análisis Base y Refinamiento con IA.")
        baseline_results_state = gr.State(value=None); file_path_state = gr.State(value=None); original_params_state = gr.State(value=None)
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 1. Carga y Configuración del Análisis Base")
                file_input = gr.File(label="📁 Archivo de Datos", file_types=[".xlsx", ".xls"]); gr.Examples(examples=["examples/archivo.xlsx"], inputs=[file_input])
                exp_names_input = gr.CheckboxGroup(label="🔬 Experimentos a Analizar", interactive=False)
                models_input = gr.CheckboxGroup(choices=BIOTECH_MODELS, value=BIOTECH_MODELS, label="📊 Modelos a Evaluar")
                component_input = gr.Dropdown(['all', 'biomass', 'substrate', 'product'], value='all', label="📈 Componente a Analizar/Filtrar")
                with gr.Accordion("Parámetros Avanzados", open=False):
                    use_de_input = gr.Checkbox(label="🧮 Usar Evolución Diferencial", value=False)
                    maxfev_input = gr.Slider(label="🔄 Máx. Iteraciones", minimum=10000, maximum=100000, value=50000, step=1000)
                run_base_analysis_btn = gr.Button("1. Ejecutar Análisis Base", variant="secondary")

                with gr.Group():
                    gr.Markdown("### 2. Refinamiento con IA")
                    gr.Markdown("#### Criterios de Selección Primarios (Filtro Estricto)")
                    r2_threshold_slider = gr.Slider(minimum=0.0, maximum=0.99, value=0.9, step=0.01, label="R² Mínimo")
                    rmse_threshold_input = gr.Number(value=0.5, label="RMSE Máximo")
                    
                    # --- NUEVO INPUT DE INSTRUCCIONES ---
                    additional_specs_input = gr.Textbox(label="📝 Instrucciones para Selección Avanzada (Plan B)",
                                                        placeholder="Ej: Usa R2 y RMSE y dame el top 2",
                                                        info="Si ningún modelo cumple los criterios de arriba, el agente seguirá estas instrucciones.")
                    
                    with gr.Accordion("Parámetros del Informe de IA Final", open=False):
                        ia_model_input = gr.Dropdown(choices=IA_MODELS, value=IA_MODELS[0], label="🤖 Modelo de IA para Informe")
                        detail_level_input = gr.Radio(['detailed', 'summarized'], value='detailed', label="📋 Nivel de Detalle")
                        language_input = gr.Dropdown(['es', 'en'], value='es', label="🌐 Idioma")
                        max_output_tokens_input = gr.Slider(minimum=1000, maximum=32000, value=8000, step=100, label="🔢 Máx. Tokens")
                        use_personal_key_input = gr.Checkbox(label="Usar Token HF Personal", value=False)
                        personal_api_key_input = gr.Textbox(label="Token HF", type="password", visible=False)
                    refine_with_ia_btn = gr.Button("2. 🤖 Aplicar Filtro y Generar Informe IA", variant="primary", interactive=False)
            with gr.Column(scale=2):
                gr.Markdown("### 3. Resultados")
                status_output = gr.Textbox(label="📊 Registro de Estado", lines=5, interactive=False)
                with gr.Tabs():
                    with gr.TabItem("📊 Visualización"): plot_output = gr.Plot()
                    with gr.TabItem("📋 Tabla de Modelado"): table_output = gr.Dataframe()
                    with gr.TabItem("📝 Informe IA"): analysis_output = gr.Markdown("El informe aparecerá aquí.")
                    with gr.TabItem("💻 Código"): code_output = gr.Code(language="python")
                    with gr.TabItem("🕵️ Registro de Agentes"): agent_log_output = gr.Markdown()
                download_link_markdown = gr.Markdown("*El enlace de descarga aparecerá aquí.*")
                report_output = gr.File(label="📥 Descargar Informe", interactive=False)
                report_path_state = gr.State(value=None)
        
        file_input.upload(fn=detect_experiments, inputs=file_input, outputs=exp_names_input)
        use_personal_key_input.change(lambda x: gr.update(visible=x), inputs=use_personal_key_input, outputs=personal_api_key_input)
        run_base_analysis_btn.click(
            fn=run_base_analysis, 
            inputs=[file_input, models_input, exp_names_input, component_input, use_de_input, maxfev_input], 
            outputs=[plot_output, table_output, status_output, refine_with_ia_btn, baseline_results_state, file_path_state, original_params_state, agent_log_output]
        )
        refine_with_ia_btn.click(
            fn=refine_and_generate_report,
            inputs=[baseline_results_state, file_path_state, original_params_state, r2_threshold_slider, rmse_threshold_input, additional_specs_input, ia_model_input, detail_level_input, language_input, max_output_tokens_input, use_personal_key_input, personal_api_key_input],
            outputs=[plot_output, table_output, analysis_output, code_output, status_output, report_path_state, agent_log_output]
        )
        def update_dl_link(path):
            if path and os.path.exists(path): return f"**¡Informe listo!** 👉 [**Descargar '{os.path.basename(path)}'**](/file={path})"
            return "*No se generó ningún archivo para descargar.*"
        report_path_state.change(fn=update_dl_link, inputs=report_path_state, outputs=download_link_markdown)
            
    demo.launch(show_error=True, debug=True)