Update app, data and requirements

app.py

@@ -0,0 +1,440 @@
+# app.py
+import gradio as gr
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+
+# -------------------------------------------------------------
+# Configuración: nombres de columnas (ajusta si tu CSV difiere)
+# -------------------------------------------------------------
+CSV_PATH = "DEP.csv"
+
+# Columnas clave según tus encabezados
+COL_SX    = "SEXO"
+COL_OWNER = "ULTIMOPROPIETARIO"
+COL_ID    = "NUMEROHATO"      # ID animal
+COL_REG   = "REGISTRO"        # Registro (opcional)
+COL_MGT   = "MGT"             # Mérito genético total
+
+# Métricas solicitadas (mapping etiqueta -> columna)
+METRIC_MAP = {
+    "Peso al nacimiento": "DEPN",
+    "Peso al destete (205d)": "DEPP205",
+    "Leche": "DEPLECHE",
+    "Materno total": "DEPMATERNOTOTAL",
+    "Peso al año (365d)": "DEPP365",
+    "CE al año": "DEPCEA",
+    "Peso a 18 meses (550d)": "DEPP550",
+    "CE a 18 meses (550d)": "DEPCE550",
+    "Mérito genético total": "MGT",
+}
+
+# Mapeo de columnas EX por métrica (None si no existe EX)
+EX_MAP = {
+    "Peso al nacimiento": "EXPN",
+    "Peso al destete (205d)": "EXP205",
+    "Leche": "EXLECHE",
+    "Materno total": None,              # no presente en tu lista
+    "Peso al año (365d)": "EXP365",
+    "CE al año": "EXCEA",
+    "Peso a 18 meses (550d)": "EXP550",
+    "CE a 18 meses (550d)": "EXCE550",
+    "Mérito genético total": None,      # sin EX
+}
+
+# Orden de métricas para la telaraña (en el mismo orden que verás en el gráfico)
+RADAR_ORDER = list(METRIC_MAP.keys())
+
+# Columnas a mostrar en tablas
+BASE_COLS = [COL_ID, COL_REG, COL_SX, COL_OWNER, COL_MGT]
+TABLE_METRIC_COLS = [METRIC_MAP[k] for k in RADAR_ORDER if METRIC_MAP[k] != COL_MGT] + [COL_MGT]
+DISPLAY_COLS = BASE_COLS + [c for c in TABLE_METRIC_COLS if c not in BASE_COLS]
+
+# Paleta
+COLOR_A = "#46973d"  # verde
+COLOR_B = "#ddb516"  # amarillo
+NEUTRAL = "#dcdcdc"  # gris claro para métricas sin EX
+
+# -------------------------------------------------------------
+# Utilidades
+# -------------------------------------------------------------
+def _coerce_numeric(df, cols):
+    for c in cols:
+        if c in df.columns:
+            df[c] = pd.to_numeric(df[c], errors="coerce")
+    return df
+
+def _normalize_minmax(x, gmin, gmax):
+    """
+    Normaliza x a [0,1] usando min-max global. Acepta x escalar o Series.
+    Devuelve SIEMPRE una Series (para que .iloc[0] funcione aguas arriba).
+    """
+    s = x if isinstance(x, pd.Series) else pd.Series([x])
+
+    # Broadcast de min/max si vienen como escalares
+    if np.isscalar(gmin):
+        min_s = pd.Series([gmin] * len(s), index=s.index)
+    elif isinstance(gmin, pd.Series):
+        min_s = gmin.reindex(s.index, fill_value=gmin.iloc[0] if len(gmin) else 0)
+    else:
+        min_s = pd.Series([0] * len(s), index=s.index)
+
+    if np.isscalar(gmax):
+        max_s = pd.Series([gmax] * len(s), index=s.index)
+    elif isinstance(gmax, pd.Series):
+        max_s = gmax.reindex(s.index, fill_value=gmax.iloc[0] if len(gmax) else 1)
+    else:
+        max_s = pd.Series([1] * len(s), index=s.index)
+
+    rng = max_s - min_s
+    rng = rng.replace(0, 1)  # evita división por cero
+    norm = (s - min_s) / rng
+    return norm.fillna(0.0).clip(0, 1)
+
+def _hex_to_rgb(hex_color):
+    hex_color = hex_color.lstrip("#")
+    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+
+def _rgb_to_hex(rgb):
+    return "#%02x%02x%02x" % rgb
+
+def _lerp_color(hex_a, hex_b, t):
+    """Interpolación lineal entre COLOR_A y COLOR_B. t en [0,1]."""
+    a = _hex_to_rgb(hex_a)
+    b = _hex_to_rgb(hex_b)
+    c = tuple(int(round(a[i] + (b[i]-a[i]) * float(t))) for i in range(3))
+    return _rgb_to_hex(c)
+
+def _build_radar_with_accuracy(values_dict, acc_dict, title):
+    """
+    values_dict: {etiqueta_métrica: valor_normalizado_0_1}
+    acc_dict:    {etiqueta_métrica: exactitud (0-100) o None}
+    Construye un plot polar con:
+      - Barras (anillo) coloreadas por exactitud EX (0->verde ... 100->amarillo)
+      - Polígono de valores normalizados
+    """
+    labels = list(values_dict.keys())
+    values = [values_dict[k] for k in labels]
+
+    # Ángulos y cierre del polígono
+    theta = labels + [labels[0]]
+    r_vals = values + [values[0]]
+
+    # Colores de exactitud por barra
+    bar_colors = []
+    for lab in labels:
+        ex = acc_dict.get(lab, None)
+        if ex is None or np.isnan(ex):
+            bar_colors.append(NEUTRAL)
+        else:
+            # Normalizamos EX esperando rango 0-100
+            t = max(0.0, min(1.0, float(ex) / 100.0))
+            bar_colors.append(_lerp_color(COLOR_A, COLOR_B, t))
+
+    fig = go.Figure()
+
+    # Anillo por exactitud (una barra por métrica)
+    fig.add_trace(
+        go.Barpolar(
+            r=[1.0] * len(labels),
+            theta=labels,
+            marker=dict(color=bar_colors, line=dict(color="white", width=1)),
+            opacity=0.6,
+            name="Exactitud (EX)",
+            hovertemplate="<b>%{theta}</b><br>Exactitud: %{marker.color}<extra></extra>"
+        )
+    )
+
+    # Polígono del valor normalizado
+    fig.add_trace(
+        go.Scatterpolar(
+            r=r_vals,
+            theta=theta,
+            mode="lines+markers",
+            fill="toself",
+            name="Valor normalizado",
+            line=dict(color=COLOR_A, width=3),
+            marker=dict(size=6, color=COLOR_B),
+            hovertemplate="<b>%{theta}</b><br>Valor: %{r:.2f}<extra></extra>"
+        )
+    )
+
+    fig.update_layout(
+        title=title,
+        showlegend=True,
+        paper_bgcolor="white",
+        polar=dict(
+            bgcolor="white",
+            radialaxis=dict(
+                visible=True,
+                range=[0, 1],
+                gridcolor="#eeeeee",
+                linecolor=COLOR_A
+            ),
+            angularaxis=dict(
+                gridcolor="#f2f2f2",
+                linecolor=COLOR_A
+            )
+        ),
+        margin=dict(l=10, r=10, t=60, b=10),
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.05,
+            xanchor="center",
+            x=0.5
+        )
+    )
+    return fig
+
+# -------------------------------------------------------------
+# Carga de datos
+# -------------------------------------------------------------
+def load_data():
+    # Si tu CSV tiene tildes/ñ raras, usa: pd.read_csv(CSV_PATH, encoding="latin-1")
+    df = pd.read_csv(CSV_PATH)
+
+    # Normaliza formatos básicos
+    if COL_SX in df.columns:
+        df[COL_SX] = df[COL_SX].astype(str).str.upper().str.strip()
+    if COL_OWNER in df.columns:
+        df[COL_OWNER] = df[COL_OWNER].astype(str).str.strip()
+
+    # A numérico
+    df = _coerce_numeric(df, list(set(TABLE_METRIC_COLS + [COL_MGT])))
+
+    # También a numérico las EX (si existen)
+    ex_cols = [c for c in EX_MAP.values() if c]
+    df = _coerce_numeric(df, ex_cols)
+
+    # Propietarios
+    owners = (
+        df[COL_OWNER].dropna().unique().tolist()
+        if COL_OWNER in df.columns else []
+    )
+    owners = sorted([o for o in owners if o not in ["", "nan"]])
+
+    # Mínimos y máximos globales para normalizar radar
+    metric_cols_present = [METRIC_MAP[k] for k in RADAR_ORDER if METRIC_MAP[k] in df.columns]
+    global_mins = df[metric_cols_present].min(numeric_only=True)
+    global_maxs = df[metric_cols_present].max(numeric_only=True)
+
+    return df, owners, global_mins, global_maxs
+
+# -------------------------------------------------------------
+# Lógica de filtros y salidas
+# -------------------------------------------------------------
+def _promedios_y_exactitud(df_subset, global_mins, global_maxs):
+    """Devuelve (values_dict_normalized, acc_dict) para un subconjunto de df."""
+    valores = {}
+    ex_vals = {}
+    for label in RADAR_ORDER:
+        dep_col = METRIC_MAP[label]
+        ex_col  = EX_MAP.get(label, None)
+
+        # valor (usa promedio del subconjunto)
+        if dep_col in df_subset.columns:
+            prom_val = pd.to_numeric(df_subset[dep_col], errors="coerce").mean()
+            valores[label] = float(_normalize_minmax(
+                prom_val,
+                global_mins.get(dep_col, 0),
+                global_maxs.get(dep_col, 1)
+            ).iloc[0])
+        else:
+            valores[label] = 0.0
+
+        # exactitud (promedio EX si existe)
+        if ex_col and ex_col in df_subset.columns:
+            ex_prom = pd.to_numeric(df_subset[ex_col], errors="coerce").mean()
+            ex_vals[label] = float(ex_prom) if pd.notnull(ex_prom) else None
+        else:
+            ex_vals[label] = None
+    return valores, ex_vals
+
+def _valores_y_exactitud_fila(row, df_cols, global_mins, global_maxs):
+    """Devuelve (values_dict_normalized, acc_dict) para una fila concreta."""
+    valores = {}
+    ex_vals = {}
+    for label in RADAR_ORDER:
+        dep_col = METRIC_MAP[label]
+        ex_col  = EX_MAP.get(label, None)
+
+        # Valor del individuo
+        if dep_col in df_cols:
+            val = pd.to_numeric(row.get(dep_col, np.nan), errors="coerce")
+            val = np.nan_to_num(val, nan=0.0)
+            valores[label] = float(_normalize_minmax(
+                val, global_mins.get(dep_col, 0), global_maxs.get(dep_col, 1)
+            ).iloc[0])
+        else:
+            valores[label] = 0.0
+
+        # Exactitud del individuo
+        if ex_col and ex_col in df_cols:
+            exv = pd.to_numeric(row.get(ex_col, np.nan), errors="coerce")
+            ex_vals[label] = float(exv) if pd.notnull(exv) else None
+        else:
+            ex_vals[label] = None
+    return valores, ex_vals
+
+def top_hembras_por_owner(df, owner, global_mins, global_maxs):
+    # Filtra por propietario y hembras
+    dff = df.copy()
+    if owner and owner != "—":
+        dff = dff[dff[COL_OWNER] == owner]
+    dff = dff[dff[COL_SX] == "H"]
+
+    # Ordena por MGT desc y limita a 30
+    dff = dff.sort_values(by=COL_MGT, ascending=False, na_position="last").head(30)
+
+    # Prepara tabla (muestra solo columnas útiles si existen)
+    cols_exist = [c for c in DISPLAY_COLS if c in dff.columns]
+    tabla = dff[cols_exist].reset_index(drop=True)
+
+    # Promedios para radar y exactitud
+    valores, ex_vals = _promedios_y_exactitud(dff, global_mins, global_maxs)
+
+    titulo = f"Promedio Hembras • {owner}" if owner else "Promedio Hembras"
+    fig = _build_radar_with_accuracy(valores, ex_vals, titulo)
+    return tabla, fig
+
+def top_machos_por_metrica(df, metric_label):
+    met_col = METRIC_MAP.get(metric_label, COL_MGT)
+    dff = df.copy()
+    dff = dff[dff[COL_SX] == "M"]
+    dff = dff.sort_values(by=met_col, ascending=False, na_position="last").head(50)
+    cols_exist = [c for c in DISPLAY_COLS if c in dff.columns]
+    tabla = dff[cols_exist].reset_index(drop=True)
+    return tabla
+
+# --- Callback del select (usa variables globales de normalización) ---
+def radar_individual_from_selection(evt: gr.SelectData, df_machos_current):
+    """
+    evt.index -> (row, col) seleccionado en la tabla de machos
+    """
+    # Accede a las normalizaciones globales ya calculadas
+    global global_mins, global_maxs
+
+    if df_machos_current is None or len(df_machos_current) == 0:
+        return gr.update(value=None)
+
+    # Índice de fila seleccionada (puede ser int o (row, col))
+    try:
+        row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+    except Exception:
+        return gr.update(value=None)
+
+    if row_idx is None or row_idx >= len(df_machos_current):
+        return gr.update(value=None)
+
+    row = df_machos_current.iloc[int(row_idx)]
+
+    valores, ex_vals = _valores_y_exactitud_fila(
+        row, df_machos_current.columns, global_mins, global_maxs
+    )
+
+    ident = str(row.get(COL_ID, "")) or "(sin ID)"
+    titulo = f"Radar individuo • {ident}"
+    fig = _build_radar_with_accuracy(valores, ex_vals, titulo)
+    return fig
+
+# -------------------------------------------------------------
+# Interfaz Gradio
+# -------------------------------------------------------------
+df_global, owners_global, global_mins, global_maxs = load_data()
+
+# Valores iniciales
+init_owner = owners_global[0] if owners_global else None
+init_tabla_h, init_fig_h = top_hembras_por_owner(df_global, init_owner, global_mins, global_maxs)
+init_tabla_m = top_machos_por_metrica(df_global, "Mérito genético total")
+
+with gr.Blocks(title="Dashboard DEP's") as demo:
+    # CSS de estilo (fondo blanco y paleta)
+    gr.HTML(f"""
+    <style>
+      body {{ background: #ffffff !important; }}
+      .gradio-container {{ background: #ffffff !important; }}
+      h1, h2, h3, .prose h1, .prose h2, .prose h3 {{ color: {COLOR_A}; }}
+      .prose p, label, .label {{ color: #222222; }}
+      .gr-button, button {{ border-radius: 10px; }}
+      .gr-input, .gr-textbox, .gr-dropdown {{ border-color: {COLOR_A}; }}
+      .gradio-container a {{ color: {COLOR_B}; }}
+    </style>
+    """)
+
+    gr.Markdown(f"# <span style='color:{COLOR_A}'>Dashboard DEP's</span>")
+    gr.Markdown(
+        "Filtra **hembras** por **ULTIMOPROPIETARIO** (top 30 por MGT) y compara con telaraña de promedios. "
+        "Debajo, ordena **machos** por la métrica seleccionada (top 50) y haz **clic** en una fila para ver la telaraña del individuo."
+    )
+
+    # Estados compartidos
+    machos_state = gr.State(value=init_tabla_m)   # guarda el DF mostrado actualmente en la tabla de machos
+
+    # --- Bloque HEMBRAS (por propietario) ---
+    with gr.Group():
+        gr.Markdown(f"## <span style='color:{COLOR_A}'>Hembras por ULTIMOPROPIETARIO</span> (Top 30 por MGT)")
+        with gr.Row():
+            dd_owner = gr.Dropdown(
+                choices=(["—"] + owners_global) if owners_global else ["—"],
+                value=(init_owner if init_owner else "—"),
+                label=f"ULTIMOPROPIETARIO (texto en {COLOR_B})"
+            )
+
+        with gr.Row():
+            out_tabla_hembras = gr.Dataframe(value=init_tabla_h, label="Hembras (Top 30 por MGT)", interactive=False)
+            out_radar_hembras = gr.Plot(value=init_fig_h, label="Telaraña: Promedios Hembras (anillo = EX)")
+
+    # --- Bloque MACHOS (ranking por métrica) ---
+    with gr.Group():
+        gr.Markdown(f"## <span style='color:{COLOR_A}'>Machos Top 50 por métrica</span> (clic en una fila para ver su telaraña)")
+        metrica_rank = gr.Dropdown(
+            choices=list(METRIC_MAP.keys()),
+            value="Mérito genético total",
+            label="Métrica para rankear machos"
+        )
+
+        # IMPORTANTE: interactive=False (no editable) y el .select sigue funcionando
+        out_tabla_machos = gr.Dataframe(value=init_tabla_m, label="Machos (Top 50)", interactive=False)
+        out_radar_macho = gr.Plot(label="Telaraña: Individuo (anillo = EX)")
+
+    # ---- Funciones de actualización ----
+    def update_hembras(owner):
+        tabla, fig = top_hembras_por_owner(df_global, owner if owner != "—" else None, global_mins, global_maxs)
+        return tabla, fig
+
+    def update_machos(metric_label):
+        tabla_m = top_machos_por_metrica(df_global, metric_label)
+        return tabla_m, tabla_m  # devolvemos también para machos_state
+
+    # Disparadores: cambio de propietario -> actualiza tabla y radar hembras
+    dd_owner.change(
+        fn=update_hembras,
+        inputs=[dd_owner],
+        outputs=[out_tabla_hembras, out_radar_hembras]
+    )
+
+    # Cambio de métrica -> actualiza machos y guarda en estado
+    metrica_rank.change(
+        fn=update_machos,
+        inputs=[metrica_rank],
+        outputs=[out_tabla_machos, machos_state]
+    )
+
+    # Click en tabla de machos -> radar del individuo (usa EX del registro)
+    out_tabla_machos.select(
+        fn=radar_individual_from_selection,
+        inputs=[machos_state],
+        outputs=[out_radar_macho]
+    )
+
+    # Crédito / pie de página
+    gr.Markdown(
+        f"<div style='text-align:center; font-size: 14px; margin-top: 12px; opacity:0.85;'>"
+        f"Elaborado por <b>Luis Arturo Arrieta</b> • Paleta <span style='color:{COLOR_A}'>{COLOR_A}</span> / <span style='color:{COLOR_B}'>{COLOR_B}</span>"
+        f"</div>"
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.36
+pandas>=2.0
+plotly>=5.20