Update app.py

app.py

@@ -1,12 +1,16 @@
 
-# app.py — MG360 (24 ítems) · Gradio Space
+
 from dataclasses import dataclass
 from typing import List, Dict, Tuple
 from datetime import datetime
 from pathlib import Path
-import os, math, json, requests
+import math
+import json
+
+# ============================
+# Núcleo MG360 (24 ítems)
+# ============================
 
-# ========== Núcleo MG360 (24 ítems) ==========
 @dataclass(frozen=True)
 class Item:
     code: str
@@ -14,6 +18,7 @@ class Item:
     dimension: str  # "COG", "EMO", "REL", "EJE"
     reverse: bool
 
+# 24 ítems: 6 por eje (3 directos + 3 inversos)
 ITEMS: List[Item] = [
     # Cognitiva (COG)
     Item("COG1", "Antes de decidir, evalúo cómo una acción afecta a otras áreas.", "COG", False),
@@ -54,24 +59,25 @@ DIMENSION_LABELS = {
 }
 
 def invert_if_needed(value: float, reverse: bool) -> float:
+    """Invierte Likert 1–5 cuando el ítem es inverso (6 - v)."""
     return 6 - value if reverse else value
 
 def score_responses(responses: Dict[str, float]) -> Dict[str, float]:
+    """Calcula promedios por dimensión y BALANCE_360."""
     dim_values = {d: [] for d in DIMENSIONS}
-    for code, v in responses.items():
-        # Validación 1..5
-        fv = float(v)
-        if not (1 <= fv <= 5):
-            raise ValueError(f"Respuesta fuera de 1-5 en {code}: {fv}")
-    # Cálculo
     for it in ITEMS:
+        if it.code not in responses:
+            raise ValueError(f"Falta respuesta para {it.code}")
         v = float(responses[it.code])
+        if not (1 <= v <= 5):
+            raise ValueError(f"Respuesta fuera de rango 1-5 en {it.code}: {v}")
         dim_values[it.dimension].append(invert_if_needed(v, it.reverse))
+
     dim_avg = {d: sum(vals)/len(vals) for d, vals in dim_values.items()}
     vals = list(dim_avg.values())
     avg = sum(vals)/len(vals)
     var = sum((x-avg)**2 for x in vals) / len(vals)
-    stdev = (var ** 0.5)
+    stdev = math.sqrt(var)
     balance_360 = 1 - (stdev / avg) if avg > 0 else 0.0
     return {**dim_avg, "BALANCE_360": balance_360}
 
@@ -80,6 +86,7 @@ def dominant_axis(dim_scores: Dict[str, float]) -> Tuple[str, float]:
     return best_dim, dim_scores[best_dim]
 
 def interpret(dim_scores: Dict[str, float]) -> Dict[str, str]:
+    """Interpretación de equilibrio y eje dominante."""
     bal = dim_scores["BALANCE_360"]
     if bal > 0.85:
         eq = "Mentalidad 360 desarrollada"
@@ -94,45 +101,68 @@ def interpret(dim_scores: Dict[str, float]) -> Dict[str, str]:
         "REL": "Conector colaborativo (Relacional)",
         "EJE": "Gestor ejecutor (Ejecucional)",
     }
-    return {"equilibrio": eq, "eje_dominante": f"{perfiles[best]} — {DIMENSION_LABELS[best]} ({val:.2f}/5)"}
+    return {
+        "equilibrio": eq,
+        "eje_dominante": f"{perfiles[best]} — {DIMENSION_LABELS[best]} ({val:.2f}/5)"
+    }
+
+# ============================
+# Radar PRO (matplotlib)
+# ============================
 
-# ========== Radar limpio y simétrico ==========
 def radar_plot(dim_scores: Dict[str, float], title: str, out_png: str) -> str:
+    """
+    Radar 4D limpio y simétrico (patrón estable):
+    - Círculo completo (0..2π)
+    - Cognitiva arriba, sentido horario
+    - Aros 1..5, etiquetas claras
+    - Valor numérico en cada eje
+    """
     import numpy as np
     import matplotlib.pyplot as plt
 
+    # Orden fijo de dimensiones (coincidirá con tus promedios)
     DIM_ORDER = ["COG", "EMO", "REL", "EJE"]
     labels = [DIMENSION_LABELS[d] for d in DIM_ORDER]
     vals   = [float(dim_scores[d]) for d in DIM_ORDER]
 
+    # Cerrar polígono (repetimos primer punto al final)
     angles = np.linspace(0, 2*np.pi, len(labels), endpoint=False)
+    angles = np.roll(angles, -0)  # no rotamos el orden base
     angles_cycle = np.concatenate([angles, [angles[0]]])
     vals_cycle   = np.concatenate([vals,   [vals[0]]])
 
+    # Lienzo polar
     fig = plt.figure(figsize=(8, 8))
     ax = plt.subplot(111, polar=True)
     ax.set_facecolor("white")
-    fig.subplots_adjust(bottom=0.18)
 
+    # Cognitiva arriba (90°) y sentido horario
     ax.set_theta_offset(np.pi / 2)
     ax.set_theta_direction(-1)
 
+    # Ticks de categorías
     ax.set_xticks(angles)
     ax.set_xticklabels(labels, fontsize=14, fontweight="bold")
 
+    # Radial 0–5 con aros visibles
     ax.set_ylim(0, 5)
     ax.set_yticks([1, 2, 3, 4, 5])
     ax.set_yticklabels(["1", "2", "3", "4", "5"], fontsize=11)
     ax.yaxis.grid(True, linewidth=0.8, alpha=0.6)
     ax.xaxis.grid(True, linewidth=0.8, alpha=0.6)
 
+    # Polígono (borde + relleno suave) — sin especificar colores
     ax.plot(angles_cycle, vals_cycle, linewidth=2.2)
     ax.fill(angles_cycle, vals_cycle, alpha=0.18)
 
+    # Marcadores + etiqueta de valor en cada eje
     for ang, v in zip(angles, vals):
         ax.plot([ang], [v], marker="o", markersize=6)
-        ax.text(ang, min(5, v + 0.22), f"{v:.2f}", ha="center", va="center", fontsize=11, fontweight="bold")
+        ax.text(ang, min(5, v + 0.22), f"{v:.2f}",
+                ha="center", va="center", fontsize=11, fontweight="bold")
 
+    # Títulos
     ax.set_title(title, fontsize=22, fontweight="bold", pad=18)
     bal = float(dim_scores.get("BALANCE_360", 0.0))
     dom = max(DIM_ORDER, key=lambda d: dim_scores[d])
@@ -144,94 +174,17 @@ def radar_plot(dim_scores: Dict[str, float], title: str, out_png: str) -> str:
     plt.close(fig)
     return out_png
 
-# ========== Prompt + LLM (Phi, InferenceClient) ==========
-from huggingface_hub import InferenceClient
 
-HF_MODEL_ID = os.environ.get("HF_MODEL_ID", "microsoft/Phi-3.5-mini-instruct")
-HF_TOKEN    = os.environ.get("HF_TOKEN", None)  # define esto en "Settings → Variables & secrets" del Space
-
-def build_prompt(scores: Dict[str, float], inter: Dict[str, str]) -> str:
-    lines = [
-        "Eres un coach ejecutivo experto en ICB4 (People, Practice, Perspective).",
-        "Con base en el siguiente diagnóstico MG360 (1–5), genera un plan de desarrollo práctico, accionable y medible.",
-        "",
-        "Resultados por eje:",
-        f"- Cognitiva:  {scores['COG']:.2f}/5",
-        f"- Emocional:  {scores['EMO']:.2f}/5",
-        f"- Relacional: {scores['REL']:.2f}/5",
-        f"- Ejecucional:{scores['EJE']:.2f}/5",
-        f"- Balance 360: {scores['BALANCE_360']:.3f}",
-        f"- Interpretación: {inter['equilibrio']} | {inter['eje_dominante']}",
-        "",
-        "Instrucciones de salida:",
-        "1) Empieza con un resumen de 2–3 líneas del perfil.",
-        "2) Para cada eje (Cognitiva, Emocional, Relacional, Ejecucional):",
-        "   - Da 3 acciones SMART (específicas, medibles, con plazos).",
-        "   - Incluye 1 indicador sugerido y 1 hábito semanal.",
-        "3) Cierra con un plan de 30 días (semanas 1–4) y riesgos comunes.",
-    ]
-    return "\\n".join(lines)
-
-def generate_plan_with_phi(prompt: str) -> str:
-    # Sin token: devolvemos aviso (el usuario puede definir HF_TOKEN en Secrets)
-    if not HF_TOKEN:
-        return ("[Aviso] Falta HF_TOKEN. Configúralo como variable de entorno "
-                "en tu Space (Settings → Variables & secrets).")
-
-    # 1) Intento con InferenceClient
-    try:
-        client = InferenceClient(HF_MODEL_ID, token=HF_TOKEN, timeout=180)
-        out = client.text_generation(
-            prompt,
-            max_new_tokens=600,
-            do_sample=True,
-            temperature=0.7,
-            top_p=0.9,
-            repetition_penalty=1.05,
-            return_full_text=False,
-        )
-        return out.strip()
-    except Exception as e:
-        err1 = f"[InferenceClient] {type(e).__name__}: {e}"
-
-    # 2) Fallback vía REST
-    try:
-        url = f"https://api-inference.huggingface.co/models/{HF_MODEL_ID}"
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "max_new_tokens": 600,
-                "do_sample": True,
-                "temperature": 0.7,
-                "top_p": 0.9,
-                "repetition_penalty": 1.05,
-                "return_full_text": False
-            }
-        }
-        r = requests.post(url, headers=headers, json=payload, timeout=180)
-        if r.status_code == 503:
-            return (f"[HF 503] El modelo {HF_MODEL_ID} está cargando o sin recurso. "
-                    f"Detalle: {r.text}")
-        r.raise_for_status()
-        data = r.json()
-        if isinstance(data, list) and data and "generated_text" in data[0]:
-            return data[0]["generated_text"].strip()
-        if isinstance(data, dict) and "generated_text" in data:
-            return data["generated_text"].strip()
-        if isinstance(data, dict) and "error" in data:
-            return f"[HF error] {data.get('error')}"
-        return f"[HF respuesta inesperada] {json.dumps(data)[:400]}..."
-    except Exception as e2:
-        err2 = f"[REST] {type(e2).__name__}: {e2}"
-        return f"[Error al llamar al modelo {HF_MODEL_ID}]\\n{err1}\\n{err2}"
-
-# ========== Utilidades Gradio ==========
+# ============================
+# Gradio App
+# ============================
 def items_schema() -> List[Dict[str, str]]:
     return [{"code": it.code, "text": it.text, "dimension": DIMENSION_LABELS[it.dimension], "reverse": it.reverse} for it in ITEMS]
 
 def _ensure_outdir() -> Path:
-    out_dir = Path("mg360_resultados"); out_dir.mkdir(parents=True, exist_ok=True); return out_dir
+    out_dir = Path("mg360_resultados")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    return out_dir
 
 def _evaluate_internal(res_vals: List[int]):
     schema = items_schema()
@@ -248,7 +201,7 @@ def _evaluate_internal(res_vals: List[int]):
     with open(out_json, "w", encoding="utf-8") as f:
         json.dump({"responses": responses, "scores": scores, "interpretation": inter}, f, ensure_ascii=False, indent=2)
 
-    # Texto de resultados
+    # Markdown de resultados
     md = [
         "**Resultados**",
         *(f"- {DIMENSION_LABELS[d]}: {scores[d]:.2f}/5" for d in ["COG","EMO","REL","EJE"]),
@@ -258,47 +211,37 @@ def _evaluate_internal(res_vals: List[int]):
         f"- Equilibrio: {inter['equilibrio']}",
         f"- Eje dominante: {inter['eje_dominante']}",
     ]
+    return str(out_png), "\n".join(md), json.dumps({"responses": responses, "scores": scores, "interpretation": inter}, ensure_ascii=False, indent=2)
+
+# ============ Lanzador Gradio ============
+def main_gradio():
+    import gradio as gr
+    schema = items_schema()
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# Test MG360 (24 ítems) — Versión Avanzada")
+        gr.Markdown("**Escala 1–5:** 1=**Nunca**, 2=**Rara vez**, 3=**A veces**, 4=**Frecuente**, 5=**Siempre**.")
+
+        with gr.Accordion("Cuestionario (24 ítems)", open=True):
+            gr.Markdown("### Guía de escala: 1=**Nunca** · 2=**Rara vez** · 3=**A veces** · 4=**Frecuente** · 5=**Siempre**")
+            sliders = [
+                gr.Slider(1, 5, step=1, value=3,
+                          label=f"{it['code']} — {it['text']} (1 Nunca · 2 Rara vez · 3 A veces · 4 Frecuente · 5 Siempre)")
+                for it in schema
+            ]
+
+        btn = gr.Button("Evaluar")
+        img = gr.Image(type="filepath", label="Radar 4D (1–5)")
+        md  = gr.Markdown()
+        js  = gr.Code(language="json", label="Reporte (JSON)")
+
+        # Importante: la función acepta múltiples parámetros (uno por slider)
+        def evaluate(*vals):
+            return _evaluate_internal(list(vals))
+
+        btn.click(fn=evaluate, inputs=sliders, outputs=[img, md, js])
 
-    # Plan de desarrollo (IA)
-    plan_prompt = build_prompt(scores, inter)
-    plan_text   = generate_plan_with_phi(plan_prompt)
-
-    return str(out_png), "\\n".join(md), json.dumps({"responses": responses, "scores": scores, "interpretation": inter}, ensure_ascii=False, indent=2), plan_text
-
-# ========== App Gradio ==========
-import gradio as gr
-
-schema = items_schema()
-with gr.Blocks() as demo:
-    gr.Markdown("# Test MG360 (24 ítems) — Versión Avanzada + Plan IA")
-    gr.Markdown("**Escala 1–5:** 1=**Nunca**, 2=**Rara vez**, 3=**A veces**, 4=**Frecuente**, 5=**Siempre**.")
-
-    with gr.Accordion("Cuestionario (24 ítems)", open=True):
-        gr.Markdown("### Guía de escala: 1=**Nunca** · 2=**Rara vez** · 3=**A veces** · 4=**Frecuente** · 5=**Siempre**")
-        sliders = [
-            gr.Slider(1, 5, step=1, value=3,
-                label=f"{it['code']} — {it['text']} (1 Nunca · 2 Rara vez · 3 A veces · 4 Frecuente · 5 Siempre)")
-            for it in schema
-        ]
-
-    with gr.Row():
-        btn = gr.Button("Evaluar", scale=1)
-        model_id = gr.Textbox(value=HF_MODEL_ID, label="HF_MODEL_ID (opcional)", scale=3)
-    img = gr.Image(type="filepath", label="Radar 4D (1–5)")
-    md  = gr.Markdown()
-    js  = gr.Code(language="json", label="Reporte (JSON)")
-    plan= gr.Markdown(label="Plan de desarrollo (IA)")
-
-    def evaluate(*vals):
-        # Permitir override del modelo por UI (no persiste, solo en sesión)
-        global HF_MODEL_ID
-        vals=list(vals)
-        HF_MODEL_ID = vals.pop() or HF_MODEL_ID
-        return _evaluate_internal(vals)
-
-    inputs = sliders + [model_id]
-    btn.click(fn=evaluate, inputs=inputs, outputs=[img, md, js, plan])
-
-# Para ejecución local:
-if __name__ == "__main__":
     demo.launch()
+
+if __name__ == "__main__":
+    main_gradio()