Delete app.py

app.py

@@ -1,504 +0,0 @@
-import numpy as np
-import pandas as pd
-import streamlit as st
-import matplotlib.pyplot as plt
-
-from zebris_extractor import extract_zebris_csv
-
-st.set_page_config(page_title="Zebris — Profil & Seuils", layout="wide")
-
-st.title("Zebris — Profil biomécanique & seuils individualisés")
-st.caption("Import de plusieurs CSV Zebris → choix d’un athlète → fiche profil + seuils personnalisés")
-
-
-with st.sidebar:
-    st.header("Import")
-    uploaded_files = st.file_uploader(
-        "Importer un ou plusieurs fichiers CSV Zebris",
-        type=["csv"],
-        accept_multiple_files=True,
-    )
-
-    if uploaded_files:
-        total_size = sum(f.size for f in uploaded_files)
-        if total_size > 100 * 1024 * 1024:
-            st.error("Volume total de fichiers trop important (>100 MB)")
-            st.stop()
-
-    st.header("Contexte")
-    volume_horaire = st.number_input(
-        "Volume horaire / semaine",
-        min_value=0.5,
-        max_value=40.0,
-        value=5.0,
-        step=0.5,
-    )
-
-if not uploaded_files:
-    st.info("Importe un ou plusieurs CSV Zebris pour afficher la fiche profil et les seuils.")
-    st.stop()
-
-
-def avg(a, b):
-    if pd.isna(a) and pd.isna(b):
-        return np.nan
-    if pd.isna(a):
-        return float(b)
-    if pd.isna(b):
-        return float(a)
-    return (float(a) + float(b)) / 2
-
-
-def asym(a, b):
-    m = avg(a, b)
-    if pd.isna(m) or m == 0 or pd.isna(a) or pd.isna(b):
-        return np.nan
-    return abs(float(a) - float(b)) / m * 100
-
-
-def clamp_score(value, low, high, reverse=False):
-    if pd.isna(value):
-        return np.nan
-    score = (value - low) / (high - low) * 100
-    score = max(0, min(100, score))
-    return 100 - score if reverse else score
-
-
-def safe_mean(values):
-    vals = [v for v in values if pd.notna(v)]
-    if not vals:
-        return np.nan
-    return float(np.mean(vals))
-
-
-def estimate_attack_type(force_talon_moy, force_avant_moy, transition_moy):
-    if pd.isna(force_talon_moy) or pd.isna(force_avant_moy) or force_avant_moy == 0:
-        return "indéterminée"
-
-    ratio = force_talon_moy / force_avant_moy
-
-    if pd.isna(transition_moy):
-        if ratio > 1.10:
-            return "attaque talon"
-        elif ratio < 0.90:
-            return "attaque avant-pied"
-        else:
-            return "attaque médio-pied"
-
-    if ratio > 1.10 and transition_moy >= 0.070:
-        return "attaque talon"
-    elif ratio < 0.90 and transition_moy <= 0.055:
-        return "attaque avant-pied"
-    else:
-        return "attaque médio-pied"
-
-
-def compute_profile_metrics(row, poids_kg):
-    poids_n = poids_kg * 9.81
-
-    force_talon_moy = avg(row["Force talon G (N)"], row["Force talon D (N)"])
-    force_avant_moy = avg(row["Force avant-pied G (N)"], row["Force avant-pied D (N)"])
-    pression_talon_moy = avg(row["Pression talon G (N/cm²)"], row["Pression talon D (N/cm²)"])
-    cop_moy = avg(row["COP G (mm)"], row["COP D (mm)"])
-    transition_moy = avg(row["Transition G (s)"], row["Transition D (s)"])
-
-    asym_talon = asym(row["Force talon G (N)"], row["Force talon D (N)"])
-    asym_avant = asym(row["Force avant-pied G (N)"], row["Force avant-pied D (N)"])
-    asym_cop = asym(row["COP G (mm)"], row["COP D (mm)"])
-
-    diff_rotation = (
-        abs(float(row["Rotation G (°)"]) - float(row["Rotation D (°)"]))
-        if pd.notna(row["Rotation G (°)"]) and pd.notna(row["Rotation D (°)"])
-        else np.nan
-    )
-
-    force_talon_bw = force_talon_moy / poids_n if pd.notna(force_talon_moy) and poids_n else np.nan
-
-    contraintes_force_score = clamp_score(force_talon_bw, 0.15, 0.45)
-    contraintes_pressure_score = clamp_score(pression_talon_moy, 3, 10)
-
-    contraintes = safe_mean([
-        0.6 * contraintes_force_score if pd.notna(contraintes_force_score) else np.nan,
-        0.4 * contraintes_pressure_score if pd.notna(contraintes_pressure_score) else np.nan,
-    ])
-    contraintes = round(contraintes) if pd.notna(contraintes) else np.nan
-
-    dynamique = safe_mean([
-        0.6 * clamp_score(row["Cadence (pas/min)"], 150, 185),
-        0.4 * clamp_score(row["Contact (%)"], 68, 76, reverse=True),
-    ])
-    dynamique = round(dynamique) if pd.notna(dynamique) else np.nan
-
-    sym_components = [x for x in [asym_talon, asym_avant, asym_cop, diff_rotation] if pd.notna(x)]
-    symetrie = round(100 - min(100, np.mean(sym_components) * 2.5)) if sym_components else np.nan
-
-    deroule = safe_mean([
-        0.5 * clamp_score(cop_moy, 210, 260),
-        0.5 * clamp_score(transition_moy, 0.05, 0.09, reverse=True),
-    ])
-    deroule = round(deroule) if pd.notna(deroule) else np.nan
-
-    attaque = estimate_attack_type(force_talon_moy, force_avant_moy, transition_moy)
-
-    return {
-        "force_talon_moy": force_talon_moy,
-        "force_avant_moy": force_avant_moy,
-        "pression_talon_moy": pression_talon_moy,
-        "cop_moy": cop_moy,
-        "transition_moy": transition_moy,
-        "asym_talon": asym_talon,
-        "asym_avant": asym_avant,
-        "asym_cop": asym_cop,
-        "diff_rotation": diff_rotation,
-        "force_talon_bw": force_talon_bw,
-        "contraintes": contraintes,
-        "dynamique": dynamique,
-        "symetrie": symetrie,
-        "deroule": deroule,
-        "attaque": attaque,
-    }
-
-
-def build_summary(row, metrics):
-    contraintes_txt = (
-        "élevées" if pd.notna(metrics["contraintes"]) and metrics["contraintes"] >= 70
-        else "modérées" if pd.notna(metrics["contraintes"]) and metrics["contraintes"] >= 45
-        else "faibles"
-    )
-    dyn_txt = (
-        "bonne" if pd.notna(metrics["dynamique"]) and metrics["dynamique"] >= 70
-        else "moyenne" if pd.notna(metrics["dynamique"]) and metrics["dynamique"] >= 45
-        else "faible"
-    )
-    sym_txt = "satisfaisante" if pd.notna(metrics["symetrie"]) and metrics["symetrie"] >= 70 else "perfectible"
-    der_txt = (
-        "favorable" if pd.notna(metrics["deroule"]) and metrics["deroule"] >= 70
-        else "intermédiaire" if pd.notna(metrics["deroule"]) and metrics["deroule"] >= 45
-        else "à surveiller"
-    )
-
-    return (
-        f"À {row['Vitesse (km/h)']} km/h, {row['Nom']} présente un type d’attaque estimé : {metrics['attaque']}, "
-        f"des contraintes mécaniques {contraintes_txt}, une dynamique {dyn_txt}, une symétrie {sym_txt} "
-        f"et un déroulé {der_txt}."
-    )
-
-
-def draw_radar(metrics):
-    labels = ["Contraintes", "Dynamique", "Symétrie", "Déroulé"]
-    values = [
-        metrics["contraintes"] if pd.notna(metrics["contraintes"]) else 0,
-        metrics["dynamique"] if pd.notna(metrics["dynamique"]) else 0,
-        metrics["symetrie"] if pd.notna(metrics["symetrie"]) else 0,
-        metrics["deroule"] if pd.notna(metrics["deroule"]) else 0,
-    ]
-    values += values[:1]
-    angles = np.linspace(0, 2 * np.pi, len(labels), endpoint=False).tolist()
-    angles += angles[:1]
-
-    fig = plt.figure(figsize=(5, 5))
-    ax = plt.subplot(111, polar=True)
-    ax.plot(angles, values, linewidth=2)
-    ax.fill(angles, values, alpha=0.25)
-    ax.set_xticks(angles[:-1])
-    ax.set_xticklabels(labels)
-    ax.set_ylim(0, 100)
-    ax.set_yticks([25, 50, 75, 100])
-    ax.set_title("Radar biomécanique", pad=20)
-    return fig
-
-
-def draw_evolution(df, poids_kg):
-    data = []
-    for _, r in df.sort_values("Vitesse (km/h)").iterrows():
-        m = compute_profile_metrics(r, poids_kg)
-        data.append({
-            "Vitesse": r["Vitesse (km/h)"],
-            "Contraintes": m["contraintes"],
-            "Dynamique": m["dynamique"],
-            "Symétrie": m["symetrie"],
-            "Déroulé": m["deroule"],
-        })
-
-    evo = pd.DataFrame(data)
-    fig, ax = plt.subplots(figsize=(8, 4))
-    for col in ["Contraintes", "Dynamique", "Symétrie", "Déroulé"]:
-        ax.plot(evo["Vitesse"], evo[col], marker="o", label=col)
-    ax.set_ylim(0, 100)
-    ax.set_xlabel("Vitesse (km/h)")
-    ax.set_ylabel("Score /100")
-    ax.set_title("Évolution avec l’allure")
-    ax.legend()
-    ax.grid(True, alpha=0.3)
-    return fig
-
-
-def compute_external_thresholds(poids_kg, volume_horaire):
-    poids_n = poids_kg * 9.81
-
-    if volume_horaire <= 3:
-        charge = "faible"
-        force_bw_low, force_bw_high = 0.25, 0.40
-        pression_low, pression_high = 4.0, 8.0
-        cadence_low, cadence_high = 160, 172
-        contact_low, contact_high = 69, 74
-        flight_low, flight_high = 26, 30
-        asym_low, asym_high = 6, 10
-        rotation_low, rotation_high = 6, 10
-
-    elif volume_horaire <= 6:
-        charge = "modérée"
-        force_bw_low, force_bw_high = 0.22, 0.37
-        pression_low, pression_high = 4.0, 7.5
-        cadence_low, cadence_high = 164, 176
-        contact_low, contact_high = 68, 73
-        flight_low, flight_high = 27, 31
-        asym_low, asym_high = 5, 9
-        rotation_low, rotation_high = 5, 9
-
-    else:
-        charge = "élevée"
-        force_bw_low, force_bw_high = 0.20, 0.35
-        pression_low, pression_high = 4.0, 7.0
-        cadence_low, cadence_high = 168, 180
-        contact_low, contact_high = 67, 72
-        flight_low, flight_high = 28, 32
-        asym_low, asym_high = 4, 8
-        rotation_low, rotation_high = 4, 8
-
-    return {
-        "charge": charge,
-        "poids_n": poids_n,
-        "force_n_low": force_bw_low * poids_n,
-        "force_n_high": force_bw_high * poids_n,
-        "pression_low": pression_low,
-        "pression_high": pression_high,
-        "cadence_low": cadence_low,
-        "cadence_high": cadence_high,
-        "contact_low": contact_low,
-        "contact_high": contact_high,
-        "flight_low": flight_low,
-        "flight_high": flight_high,
-        "asym_low": asym_low,
-        "asym_high": asym_high,
-        "rotation_low": rotation_low,
-        "rotation_high": rotation_high,
-    }
-
-
-dfs = []
-load_errors = []
-
-for f in uploaded_files:
-    try:
-        df_one, debug = extract_zebris_csv(f)
-        if not df_one.empty:
-            df_one["Source fichier"] = f.name
-            dfs.append(df_one)
-        else:
-            load_errors.append(f"{f.name} : aucune ligne exploitable")
-    except Exception as e:
-        load_errors.append(f"{f.name} : {e}")
-
-if load_errors:
-    for err in load_errors:
-        st.warning(err)
-
-if not dfs:
-    st.error("Aucun fichier exploitable n’a pu être importé.")
-    st.stop()
-
-df_std = pd.concat(dfs, ignore_index=True)
-
-all_athletes = sorted(df_std["Nom"].dropna().unique().tolist())
-selected_athlete = st.selectbox("Athlète", all_athletes)
-
-sub_df = df_std[df_std["Nom"] == selected_athlete].copy()
-if sub_df.empty:
-    st.error("Aucune donnée trouvée pour cet athlète.")
-    st.stop()
-
-sources = sorted(sub_df["Source fichier"].dropna().unique().tolist())
-if len(sources) > 1:
-    selected_source = st.selectbox("Fichier source", sources)
-    sub_df = sub_df[sub_df["Source fichier"] == selected_source].copy()
-
-sub_df = sub_df.sort_values("Vitesse (km/h)")
-speeds = sub_df["Vitesse (km/h)"].dropna().tolist()
-selected_speed = st.selectbox("Allure analysée (km/h)", speeds)
-row = sub_df[sub_df["Vitesse (km/h)"] == selected_speed].iloc[0]
-
-poids_csv = row["Poids (kg)"] if pd.notna(row["Poids (kg)"]) else np.nan
-poids_kg = st.number_input(
-    "Poids du sportif (kg)",
-    min_value=30.0,
-    max_value=150.0,
-    value=float(poids_csv) if pd.notna(poids_csv) else 70.0,
-    step=0.1,
-)
-
-metrics = compute_profile_metrics(row, poids_kg)
-summary = build_summary(row, metrics)
-thresholds = compute_external_thresholds(poids_kg, volume_horaire)
-
-tab_profil, tab_seuils = st.tabs(["Profil biomécanique", "Seuils individualisés"])
-
-with tab_profil:
-    c1, c2, c3, c4 = st.columns(4)
-    with c1:
-        st.metric("Contraintes", f"{metrics['contraintes']}/100" if pd.notna(metrics["contraintes"]) else "N/A")
-    with c2:
-        st.metric("Dynamique", f"{metrics['dynamique']}/100" if pd.notna(metrics["dynamique"]) else "N/A")
-    with c3:
-        st.metric("Symétrie", f"{metrics['symetrie']}/100" if pd.notna(metrics["symetrie"]) else "N/A")
-    with c4:
-        st.metric("Déroulé", f"{metrics['deroule']}/100" if pd.notna(metrics["deroule"]) else "N/A")
-
-    left, right = st.columns([1.2, 1])
-
-    with left:
-        st.subheader("Carte d’identité biomécanique")
-        st.write(summary)
-
-        indicators = pd.DataFrame(
-            {
-                "Indicateur": [
-                    "Fichier source",
-                    "Poids",
-                    "Cadence",
-                    "Contact",
-                    "Flight",
-                    "Force talon moyenne",
-                    "Pression talon moyenne",
-                    "Asymétrie talon",
-                    "COP moyen",
-                    "Différence rotation",
-                    "Type d’attaque estimé",
-                ],
-                "Valeur": [
-                    row.get("Source fichier", "N/A"),
-                    f"{poids_kg:.1f} kg",
-                    f"{row['Cadence (pas/min)']:.1f} pas/min" if pd.notna(row["Cadence (pas/min)"]) else "N/A",
-                    f"{row['Contact (%)']:.1f} %" if pd.notna(row["Contact (%)"]) else "N/A",
-                    f"{row['Flight (%)']:.1f} %" if pd.notna(row["Flight (%)"]) else "N/A",
-                    f"{metrics['force_talon_moy']:.1f} N" if pd.notna(metrics["force_talon_moy"]) else "N/A",
-                    f"{metrics['pression_talon_moy']:.1f} N/cm²" if pd.notna(metrics["pression_talon_moy"]) else "N/A",
-                    f"{metrics['asym_talon']:.1f} %" if pd.notna(metrics["asym_talon"]) else "N/A",
-                    f"{metrics['cop_moy']:.1f} mm" if pd.notna(metrics["cop_moy"]) else "N/A",
-                    f"{metrics['diff_rotation']:.1f}°" if pd.notna(metrics["diff_rotation"]) else "N/A",
-                    metrics["attaque"],
-                ],
-            }
-        )
-        st.dataframe(indicators, hide_index=True, use_container_width=True)
-
-    with right:
-        st.subheader("Radar biomécanique")
-        st.pyplot(draw_radar(metrics), use_container_width=True)
-
-    st.subheader("Évolution avec l’allure")
-    st.pyplot(draw_evolution(sub_df, poids_kg), use_container_width=True)
-
-    st.subheader("Type d’attaque estimé selon l’allure")
-    attaque_rows = []
-    for _, r in sub_df.iterrows():
-        m = compute_profile_metrics(r, poids_kg)
-        attaque_rows.append({
-            "Allure (km/h)": r["Vitesse (km/h)"],
-            "Type d’attaque estimé": m["attaque"],
-            "Transition moyenne (s)": round(m["transition_moy"], 3) if pd.notna(m["transition_moy"]) else np.nan,
-            "Force talon moyenne (N)": round(m["force_talon_moy"], 1) if pd.notna(m["force_talon_moy"]) else np.nan,
-            "Force avant-pied moyenne (N)": round(m["force_avant_moy"], 1) if pd.notna(m["force_avant_moy"]) else np.nan,
-        })
-    st.dataframe(pd.DataFrame(attaque_rows), hide_index=True, use_container_width=True)
-
-with tab_seuils:
-    r1, r2, r3 = st.columns(3)
-    with r1:
-        st.metric("Poids", f"{poids_kg:.1f} kg")
-    with r2:
-        st.metric("Poids en Newton", f"{thresholds['poids_n']:.1f} N")
-    with r3:
-        st.metric("Charge", thresholds["charge"])
-
-    impact_df = pd.DataFrame({
-        "Variable": [
-            "Force talon",
-            "Pression talon",
-        ],
-        "Zone basse / faible": [
-            f"< {thresholds['force_n_low']:.1f} N",
-            f"< {thresholds['pression_low']:.1f} N/cm²",
-        ],
-        "Zone attendue": [
-            f"{thresholds['force_n_low']:.1f} à {thresholds['force_n_high']:.1f} N",
-            f"{thresholds['pression_low']:.1f} à {thresholds['pression_high']:.1f} N/cm²",
-        ],
-        "Zone haute / élevée": [
-            f"> {thresholds['force_n_high']:.1f} N",
-            f"> {thresholds['pression_high']:.1f} N/cm²",
-        ],
-    })
-
-    dynamique_df = pd.DataFrame({
-        "Variable": [
-            "Cadence",
-            "Temps de contact",
-            "Temps de vol",
-        ],
-        "Zone basse / faible": [
-            f"< {thresholds['cadence_low']} pas/min",
-            f"< {thresholds['contact_low']} %",
-            f"< {thresholds['flight_low']} %",
-        ],
-        "Zone attendue": [
-            f"{thresholds['cadence_low']} à {thresholds['cadence_high']} pas/min",
-            f"{thresholds['contact_low']} à {thresholds['contact_high']} %",
-            f"{thresholds['flight_low']} à {thresholds['flight_high']} %",
-        ],
-        "Zone haute / élevée": [
-            f"> {thresholds['cadence_high']} pas/min",
-            f"> {thresholds['contact_high']} %",
-            f"> {thresholds['flight_high']} %",
-        ],
-    })
-
-    symetrie_df = pd.DataFrame({
-        "Variable": [
-            "Asymétrie force talon",
-            "Asymétrie force avant-pied",
-            "Asymétrie COP",
-            "Différence rotation G/D",
-        ],
-        "Zone faible": [
-            f"< {thresholds['asym_low']} %",
-            f"< {thresholds['asym_low']} %",
-            f"< {thresholds['asym_low']} %",
-            f"< {thresholds['rotation_low']}°",
-        ],
-        "Zone modérée": [
-            f"{thresholds['asym_low']} à {thresholds['asym_high']} %",
-            f"{thresholds['asym_low']} à {thresholds['asym_high']} %",
-            f"{thresholds['asym_low']} à {thresholds['asym_high']} %",
-            f"{thresholds['rotation_low']} à {thresholds['rotation_high']}°",
-        ],
-        "Zone marquée": [
-            f"> {thresholds['asym_high']} %",
-            f"> {thresholds['asym_high']} %",
-            f"> {thresholds['asym_high']} %",
-            f"> {thresholds['rotation_high']}°",
-        ],
-    })
-
-    s1, s2, s3 = st.tabs(["Impact", "Dynamique", "Symétrie"])
-    with s1:
-        st.dataframe(impact_df, hide_index=True, use_container_width=True)
-    with s2:
-        st.dataframe(dynamique_df, hide_index=True, use_container_width=True)
-    with s3:
-        st.dataframe(symetrie_df, hide_index=True, use_container_width=True)
-
-    st.write(
-        "Ces seuils sont individualisés à partir du poids et du volume horaire hebdomadaire. "
-        "Les données biomécaniques Zebris ne servent pas à fabriquer les seuils, mais à être comparées à eux."
-    )