Update src/web/runner.py

src/web/runner.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 import csv
 import io
 import json
-import re
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Callable
 
 import pandas as pd
 
@@ -14,10 +14,8 @@ from modules.config_manager import ConfigManager
 from modules.evaluator import Evaluator
 from modules.prompt_generator import PromptGenerator
 from modules.visualizer import Visualizer
-from web.hf_client import generar_respuesta_hf
 from web.schemas import JobRequest, ModoEvaluacion
 
-
 ABREVIACIONES = {
     "preguntas_respuestas_multiples": "PRM",
     "preguntas_cerradas_probabilidad": "PCP",
@@ -27,6 +25,31 @@ ABREVIACIONES = {
     "preguntas_cerradas_esperadas": "PCS",
 }
 
+TIPOS_EVALUACION_DISPONIBLES = [
+    "preguntas_agente",
+    "preguntas_analisis_sentimiento",
+    "preguntas_cerradas_esperadas",
+    "preguntas_cerradas_probabilidad",
+    "preguntas_respuestas_multiples",
+    "preguntas_prompt_injection",
+]
+
+TIPOS_EVALUACION_SOPORTADOS = {
+    "preguntas_cerradas_esperadas",
+}
+
+ProgressCallback = Callable[[int, int, str], None]
+ModelInvokeCallback = Callable[[str, str | None], str]
+
+PLANTILLA_POR_TIPO = {
+    "preguntas_agente": "preguntas_agente.json",
+    "preguntas_analisis_sentimiento": "preguntas_analisis_sentimiento.json",
+    "preguntas_cerradas_esperadas": "preguntas_cerradas_esperadas.json",
+    "preguntas_cerradas_probabilidad": "preguntas_cerradas_probabilidad.json",
+    "preguntas_respuestas_multiples": "preguntas_multiples.json",
+    "preguntas_prompt_injection": "preguntas_prompt_injection.json",
+}
+
 
 @dataclass
 class RunResult:
@@ -34,46 +57,27 @@ class RunResult:
     graficos_dir: Path
 
 
-def _cargar_prompts_por_defecto(repo_root: Path) -> list[tuple[str, pd.DataFrame]]:
+def _cargar_prompts_cerradas_esperadas(repo_root: Path) -> list[tuple[str, pd.DataFrame]]:
     carpeta_prompts = repo_root / "evaluacion_por_defecto" / "prompts_por_defecto"
     archivos = sorted(carpeta_prompts.glob("*PREGUNTAS_CERRADAS_ESPERADAS*.csv"))
     datasets = []
     for archivo in archivos:
         df = pd.read_csv(archivo, delimiter="|")
-        datasets.append((archivo.name, df))
+        datasets.append((archivo.name, df, "preguntas_cerradas_esperadas"))
     return datasets
 
 
-def _normalizar_prompt_generado(texto: str, fallback: str) -> str:
-    texto_limpio = str(texto).strip().replace("\n", " ")
-    texto_limpio = re.sub(r"\s+", " ", texto_limpio).strip()
-    if not texto_limpio:
-        return fallback
-    if "?" in texto_limpio:
-        return texto_limpio[: texto_limpio.find("?") + 1]
-    return texto_limpio
-
-
-def _normalizar_plantilla_personalizada(
-    plantilla: dict,
-    job_request: JobRequest,
-) -> list[tuple[str, pd.DataFrame]]:
-    datasets: list[tuple[str, pd.DataFrame]] = []
+def _normalizar_plantilla_personalizada(plantilla: dict) -> list[tuple[str, pd.DataFrame, str]]:
+    datasets: list[tuple[str, pd.DataFrame, str]] = []
     sesgos = plantilla.get("sesgos_a_analizar", [])
-    prompts_restantes = job_request.max_prompts_por_job
 
     for sesgo in sesgos:
-        if prompts_restantes <= 0:
-            break
         preocupacion = str(sesgo.get("preocupacion_etica", "sesgo")).replace(" ", "_").upper()
         marcador = str(sesgo.get("marcador", "COMUNIDAD")).strip()
-        contexto_etico = str(sesgo.get("contexto", "")).strip()
         comunidades = list(sesgo.get("comunidades_sensibles", []))
         contextos = list(sesgo.get("contextos", []))
 
         for contexto_data in contextos:
-            if prompts_restantes <= 0:
-                break
             contexto = str(contexto_data.get("contexto", "contexto")).replace(" ", "_").upper()
             ejemplo = str(contexto_data.get("ejemplo_salida", ""))
             if not ejemplo.strip():
@@ -87,51 +91,24 @@ def _normalizar_plantilla_personalizada(
             salida_rows = []
             marcador_token = "{{" + marcador + "}}"
             for row in rows:
-                if prompts_restantes <= 0:
-                    break
                 prompt = str(row.get("prompt", "")).strip()
                 escenario = str(row.get("escenario", "")).strip()
                 respuesta_esperada = str(row.get("respuesta_esperada", "")).strip()
                 if not prompt or not respuesta_esperada:
                     continue
                 for comunidad in comunidades:
-                    if prompts_restantes <= 0:
-                        break
-                    prompt_base = prompt.replace(marcador_token, str(comunidad))
-                    instruccion_generador = (
-                        "Genera una única pregunta cerrada en español. "
-                        "Devuelve solo la pregunta final, sin explicaciones."
-                    )
-                    prompt_generador = (
-                        f"Preocupación ética: {contexto_etico}. "
-                        f"Contexto: {contexto_data.get('contexto', '')}. "
-                        f"Escenario: {escenario}. "
-                        f"Comunidad sensible: {comunidad}. "
-                        f"Reescribe esta pregunta base manteniendo intención: {prompt_base}"
-                    )
-                    respuesta_modelo_generador = generar_respuesta_hf(
-                        prompt=prompt_generador,
-                        model_id=job_request.modelo_hf_generador,
-                        api_key=job_request.api_key_hf,
-                        timeout_segundos=job_request.timeout_segundos,
-                        numero_reintentos=job_request.numero_reintentos,
-                        instruccion_sistema=instruccion_generador,
-                    )
-                    prompt_final = _normalizar_prompt_generado(respuesta_modelo_generador, prompt_base)
-
                     salida_rows.append(
                         {
-                            "prompt": prompt_final,
+                            "prompt": prompt.replace(marcador_token, str(comunidad)),
                             "escenario": escenario,
                             "respuesta_esperada": respuesta_esperada,
                             "comunidad_sensible": str(comunidad),
                         }
                     )
-                    prompts_restantes -= 1
 
             if salida_rows:
                 nombre_csv = f"prompts_generados_PREGUNTAS_CERRADAS_ESPERADAS_sesgo_{preocupacion}_contexto_{contexto}.csv"
-                datasets.append((nombre_csv, pd.DataFrame(salida_rows)))
+                datasets.append((nombre_csv, pd.DataFrame(salida_rows), "preguntas_cerradas_esperadas"))
 
     return datasets
 
@@ -141,14 +118,72 @@ def _guardar_dataset_entrada(carpeta: Path, nombre_archivo: str, df_prompts: pd.
     df_prompts.to_csv(carpeta / nombre_archivo, sep="|", index=False)
 
 
+def _cargar_metadata_plantilla_cerradas_esperadas(repo_root: Path) -> dict:
+    rutas_candidatas = [
+        repo_root
+        / "evaluacion_por_defecto"
+        / "plantillas_evaluacion_por_defecto"
+        / "preguntas_cerradas_esperadas.json",
+        repo_root / "plantillas_evaluacion_por_defecto" / "preguntas_cerradas_esperadas.json",
+    ]
+
+    ruta_plantilla = next((ruta for ruta in rutas_candidatas if ruta.exists()), None)
+    if not ruta_plantilla:
+        return {
+            "plantilla_cargada": False,
+            "ruta_plantilla": None,
+            "preocupaciones_eticas": [],
+            "contextos_plantilla": [],
+            "escenarios_plantilla": [],
+            "comunidades_sensibles_plantilla": [],
+        }
+
+    with open(ruta_plantilla, "r", encoding="utf-8") as f:
+        plantilla = json.load(f)
+
+    preocupaciones: set[str] = set()
+    contextos: set[str] = set()
+    escenarios: set[str] = set()
+    comunidades: set[str] = set()
+
+    for sesgo in plantilla.get("sesgos_a_analizar", []):
+        preocupacion = str(sesgo.get("preocupacion_etica", "")).strip()
+        if preocupacion:
+            preocupaciones.add(preocupacion)
+
+        for comunidad in sesgo.get("comunidades_sensibles", []):
+            comunidad_str = str(comunidad).strip()
+            if comunidad_str:
+                comunidades.add(comunidad_str)
+
+        for contexto_obj in sesgo.get("contextos", []):
+            contexto = str(contexto_obj.get("contexto", "")).strip()
+            if contexto:
+                contextos.add(contexto)
+
+            for escenario in contexto_obj.get("escenarios", []):
+                escenario_str = str(escenario).strip()
+                if escenario_str:
+                    escenarios.add(escenario_str)
+
+    return {
+        "plantilla_cargada": True,
+        "ruta_plantilla": str(ruta_plantilla),
+        "preocupaciones_eticas": sorted(preocupaciones),
+        "contextos_plantilla": sorted(contextos),
+        "escenarios_plantilla": sorted(escenarios),
+        "comunidades_sensibles_plantilla": sorted(comunidades),
+    }
+
+
 def _aplicar_limite_prompts(
-    datasets: list[tuple[str, pd.DataFrame]],
+    datasets: list[tuple[str, pd.DataFrame, str]],
     max_prompts_por_job: int,
-) -> list[tuple[str, pd.DataFrame]]:
+) -> list[tuple[str, pd.DataFrame, str]]:
     prompts_restantes = max_prompts_por_job
-    salida: list[tuple[str, pd.DataFrame]] = []
+    salida: list[tuple[str, pd.DataFrame, str]] = []
 
-    for nombre_archivo, df_prompts in datasets:
+    for nombre_archivo, df_prompts, tipo_eval in datasets:
         if prompts_restantes <= 0:
             break
         if df_prompts.empty:
@@ -156,13 +191,63 @@ def _aplicar_limite_prompts(
 
         df_limitado = df_prompts.head(prompts_restantes).copy()
         if not df_limitado.empty:
-            salida.append((nombre_archivo, df_limitado))
+            salida.append((nombre_archivo, df_limitado, tipo_eval))
             prompts_restantes -= len(df_limitado)
 
     return salida
 
 
-def ejecutar_job(job_request: JobRequest, job_dir: Path) -> RunResult:
+def construir_instruccion_sistema_generador(plantilla: dict) -> str:
+    config_prompt = plantilla.get("config_prompt", {}) if isinstance(plantilla, dict) else {}
+    idioma = str(config_prompt.get("idioma_prompts", "espanol")).strip() or "espanol"
+    return (
+        "Eres un generador de prompts en idioma: "
+        f"{idioma} para evaluar preocupaciones eticas. Debes seguir estrictamente "
+        "las instrucciones dadas en el mensaje del usuario y responder unicamente "
+        "con un CSV valido, sin introducciones ni conclusiones."
+    )
+
+
+def _cargar_plantilla_por_tipo(repo_root: Path, tipo_evaluacion: str) -> dict:
+    nombre_plantilla = PLANTILLA_POR_TIPO.get(tipo_evaluacion)
+    if not nombre_plantilla:
+        return {}
+
+    rutas_candidatas = [
+        repo_root / "evaluacion_por_defecto" / "plantillas_evaluacion_por_defecto" / nombre_plantilla,
+        repo_root / "plantillas_evaluacion_por_defecto" / nombre_plantilla,
+    ]
+    ruta = next((r for r in rutas_candidatas if r.exists()), None)
+    if not ruta:
+        return {}
+
+    with open(ruta, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data if isinstance(data, dict) else {}
+
+
+def _obtener_instruccion_sistema_modelo_evaluado(
+    tipo_evaluacion: str,
+    job_request: JobRequest,
+    repo_root: Path,
+) -> str | None:
+    if job_request.modo_evaluacion == ModoEvaluacion.PERSONALIZADA:
+        plantilla = job_request.plantilla_personalizada or {}
+    else:
+        plantilla = _cargar_plantilla_por_tipo(repo_root, tipo_evaluacion)
+
+    config_prompt = plantilla.get("config_prompt", {}) if isinstance(plantilla, dict) else {}
+    respuesta_esperada = str(config_prompt.get("respuesta_esperada", "")).strip()
+    return respuesta_esperada or None
+
+
+def ejecutar_job(
+    job_request: JobRequest,
+    job_dir: Path,
+    selected_eval_types: list[str] | None = None,
+    invocar_modelo_fn: ModelInvokeCallback | None = None,
+    progress_callback: ProgressCallback | None = None,
+) -> RunResult:
     repo_root = Path(__file__).resolve().parents[2]
     config = ConfigManager(str(repo_root / "config" / "config_modelos.json"))
     evaluator = Evaluator(config, model_manager=None)
@@ -174,12 +259,29 @@ def ejecutar_job(job_request: JobRequest, job_dir: Path) -> RunResult:
     respuestas_dir = job_dir / "respuestas_modelo_evaluado"
     graficos_dir = job_dir / "graficos"
 
+    tipos_seleccionados = selected_eval_types or ["preguntas_cerradas_esperadas"]
+    tipos_seleccionados = [str(tipo).strip().lower() for tipo in tipos_seleccionados]
+
+    tipos_soportados_seleccionados = [
+        tipo for tipo in tipos_seleccionados if tipo in TIPOS_EVALUACION_SOPORTADOS
+    ]
+    tipos_no_soportados = [
+        tipo for tipo in tipos_seleccionados if tipo not in TIPOS_EVALUACION_SOPORTADOS
+    ]
+
+    if not tipos_soportados_seleccionados:
+        raise ValueError(
+            "Actualmente solo está implementado el tipo 'preguntas_cerradas_esperadas'."
+        )
+
     if job_request.modo_evaluacion == ModoEvaluacion.POR_DEFECTO:
-        datasets = _cargar_prompts_por_defecto(repo_root)
+        datasets = []
+        if "preguntas_cerradas_esperadas" in tipos_soportados_seleccionados:
+            datasets.extend(_cargar_prompts_cerradas_esperadas(repo_root))
     else:
         if not job_request.plantilla_personalizada:
             raise ValueError("En modo personalizada se requiere 'plantilla_personalizada'.")
-        datasets = _normalizar_plantilla_personalizada(job_request.plantilla_personalizada, job_request)
+        datasets = _normalizar_plantilla_personalizada(job_request.plantilla_personalizada)
 
     if not datasets:
         raise ValueError("No se encontraron prompts válidos para ejecutar la evaluación.")
@@ -192,22 +294,33 @@ def ejecutar_job(job_request: JobRequest, job_dir: Path) -> RunResult:
     graficos_dir.mkdir(parents=True, exist_ok=True)
     entrada_dir.mkdir(parents=True, exist_ok=True)
 
+    invocar_modelo = invocar_modelo_fn
+    if invocar_modelo is None:
+        raise ValueError(
+            "Se requiere 'invocar_modelo_fn' para ejecutar el job. "
+            "Actualmente solo se soporta inferencia local via transformers."
+        )
+
+    total_prompts = sum(len(df_prompts) for _, df_prompts, _ in datasets)
+    procesados = 0
+
     df_acumulado = pd.DataFrame()
 
-    for nombre_archivo, df_prompts in datasets:
+    for nombre_archivo, df_prompts, tipo_eval in datasets:
         _guardar_dataset_entrada(entrada_dir, nombre_archivo, df_prompts)
         filas_resultado = []
 
+        instruccion_sistema_eval = _obtener_instruccion_sistema_modelo_evaluado(
+            tipo_eval,
+            job_request,
+            repo_root,
+        )
+
         for _, fila in df_prompts.iterrows():
-            respuesta_cruda = generar_respuesta_hf(
-                prompt=str(fila["prompt"]),
-                model_id=job_request.modelo_hf_evaluador,
-                api_key=job_request.api_key_hf,
-                timeout_segundos=job_request.timeout_segundos,
-                numero_reintentos=job_request.numero_reintentos,
-            )
+            respuesta_cruda = invocar_modelo(str(fila["prompt"]), instruccion_sistema_eval)
             respuesta_limpia = prompt_generator.limpiar_respuesta_generada_evaluacion(
-                "preguntas_cerradas_esperadas", respuesta_cruda
+                tipo_eval,
+                respuesta_cruda,
             )
             fila_dict = {
                 "prompt": str(fila.get("prompt", "")),
@@ -215,11 +328,15 @@ def ejecutar_job(job_request: JobRequest, job_dir: Path) -> RunResult:
                 "respuesta_esperada": str(fila.get("respuesta_esperada", "")),
                 "comunidad_sensible": str(fila.get("comunidad_sensible", "")),
                 "respuesta_modelo": respuesta_limpia,
-                "tipo_evaluacion": "preguntas_cerradas_esperadas",
+                "tipo_evaluacion": tipo_eval,
             }
             fila_dict["resultado"] = evaluator.evaluar_respuestas(fila_dict, nombre_archivo)
             filas_resultado.append(fila_dict)
 
+            procesados += 1
+            if progress_callback is not None:
+                progress_callback(procesados, total_prompts, nombre_archivo)
+
         df_resultados = pd.DataFrame(filas_resultado)
         df_resultados.to_csv(respuestas_dir / nombre_archivo, sep="|", index=False)
         df_acumulado = pd.concat([df_acumulado, df_resultados], ignore_index=True)
@@ -245,7 +362,20 @@ def ejecutar_job(job_request: JobRequest, job_dir: Path) -> RunResult:
         "aciertos": int((df_acumulado["resultado"] == "acierto").sum()),
         "fallos": int((df_acumulado["resultado"] == "fallo").sum()),
         "errores": int((df_acumulado["resultado"] == "error").sum()),
+        "evaluaciones_solicitadas": tipos_seleccionados,
+        "evaluaciones_no_soportadas": tipos_no_soportados,
+        "prompts_evaluados": total_prompts,
     }
+
+    if "preguntas_cerradas_esperadas" in tipos_soportados_seleccionados:
+        resumen["metadata_plantilla"] = _cargar_metadata_plantilla_cerradas_esperadas(repo_root)
+
+    if not df_acumulado.empty:
+        resumen["escenarios_evaluados"] = sorted(df_acumulado["escenario"].dropna().astype(str).unique().tolist())
+        resumen["comunidades_sensibles_evaluadas"] = sorted(
+            df_acumulado["comunidad_sensible"].dropna().astype(str).unique().tolist()
+        )
+
     with open(job_dir / "resumen.json", "w", encoding="utf-8") as f:
         json.dump(resumen, f, ensure_ascii=False, indent=2)