21 · Les têtes du Big 5, notebook de preuve

import datetime
import hashlib
import json
import platform
from pathlib import Path

import numpy as np
import pandas as pd
from scipy.stats import chi2_contingency, linregress, norm

RACINE = Path("preuves/data")
SORTIE = Path("preuves/out")
ENTREES = {
    "21-headers.csv.gz": [
        "season", "league", "team_id", "player_id", "dist", "lat", "situation",
        "delivery", "outcome_raw", "assist_player_id", "is_goal", "is_on_target",
        "goal_mouth_y", "goal_mouth_z", "assist_valid",
    ],
    "21-tete-pied.csv": ["partie", "tirs", "buts", "cadres", "buts_cadres"],
    "21-perimetre.csv": ["cle", "valeur"],
    "21-joueurs.csv": ["player_id", "player", "headers", "goals"],
    "21-passeurs.csv": ["assist_player_id", "assist_player", "headers", "goals"],
    "21-equipes.csv": ["team_id", "team"],
    "21-matches.csv": ["season", "league", "matches"],
}
manquants = [nom for nom in ENTREES if not (RACINE / nom).exists()]
if manquants:
    raise FileNotFoundError(
        "Corpus incomplet, rien n'est calculé. Fichiers attendus dans preuves/data/ : "
        + ", ".join(manquants) + ". Ils sont produits depuis header_analysis/data/.")

for nom, colonnes in ENTREES.items():
    table = pd.read_csv(RACINE / nom, sep=";", nrows=0)
    assert list(table.columns) == colonnes, (nom, list(table.columns))

h = pd.read_csv(
    RACINE / "21-headers.csv.gz", sep=";",
    dtype={"team_id": "int64", "player_id": "int64", "assist_player_id": "Int64"})
tete_pied = pd.read_csv(RACINE / "21-tete-pied.csv", sep=";")
perimetre = pd.read_csv(RACINE / "21-perimetre.csv", sep=";").set_index("cle")["valeur"]
joueurs = pd.read_csv(RACINE / "21-joueurs.csv", sep=";", dtype={"player_id": "int64"})
passeurs = pd.read_csv(RACINE / "21-passeurs.csv", sep=";", dtype={"assist_player_id": "Int64"})
equipes = pd.read_csv(RACINE / "21-equipes.csv", sep=";", dtype={"team_id": "int64"})
matchs = pd.read_csv(RACINE / "21-matches.csv", sep=";")

print(f"{len(h):,} têtes · {h.season.nunique()} saisons · {h.league.nunique()} ligues".replace(",", " "))

assert int(perimetre["tirs_archive"]) == 783173
assert int(perimetre["tirs_2009_2026"]) == 783173
assert int(perimetre["tetes_csc"]) == 486
assert int(perimetre["tetes_brutes"]) - int(perimetre["tetes_csc"]) == 131531
assert int(perimetre["tetes_retenues"]) == 131531
assert int(perimetre["buts_big5"]) == 81860
assert int(perimetre["matchs"]) == 30692

assert len(h) == 131531
assert int(h.is_goal.sum()) == 13921
assert h.season.nunique() == 17 and h.league.nunique() == 5
assert h.season.min() == "2009-2010" and h.season.max() == "2025-2026"
assert "2026-2027" not in set(h.season)
assert len(matchs) == 85 and matchs.season.nunique() == 17 and matchs.league.nunique() == 5
assert int(matchs.matches.sum()) == 30692
assert int(h.assist_valid.sum()) == 124931
assert int(h.is_on_target.sum()) == int(tete_pied.loc[tete_pied.partie == "Tete", "cadres"].iloc[0])
print("périmètre vérifié : 131 531 têtes · 486 CSC exclus · 30 692 matchs")

def wilson(k, n, z=1.96):
    p = k / n
    den = 1 + z * z / n
    centre = (p + z * z / (2 * n)) / den
    demi = z * np.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / den
    return max(0.0, centre - demi), min(1.0, centre + demi)


n = len(h)
buts = int(h.is_goal.sum())
conversion = 100.0 * buts / n
cadrage = 100.0 * float(h.is_on_target.mean())
conversion_cadrees = 100.0 * float(h.loc[h.is_on_target, "is_goal"].mean())

tete_pied_idx = tete_pied.set_index("partie")
tete, pied = tete_pied_idx.loc["Tete"], tete_pied_idx.loc["Pied"]
assert int(tete["tirs"]) == n and int(tete["buts"]) == buts
conversion_pied = 100.0 * float(pied["buts"]) / float(pied["tirs"])
cadrage_pied = 100.0 * float(pied["cadres"]) / float(pied["tirs"])
conversion_cadrees_pied = 100.0 * float(pied["buts_cadres"]) / float(pied["cadres"])
part_tirs = 100.0 * n / int(perimetre["tirs_2009_2026"])
part_buts = 100.0 * buts / int(perimetre["buts_big5"])

matchs_saison = matchs.groupby("season").matches.sum()
saison = (
    h.groupby("season")
    .agg(tetes=("is_goal", "size"), buts=("is_goal", "sum"), cadres=("is_on_target", "sum"))
    .reset_index()
)
saison["matchs"] = saison.season.map(matchs_saison)
saison["season_start"] = saison.season.str[:4].astype(int)
saison["label"] = saison.season_start.astype(str).str[-2:] + "/" + (saison.season_start + 1).astype(str).str[-2:]
saison["tetes_par_match"] = saison.tetes / saison.matchs
saison["conversion"] = 100.0 * saison.buts / saison.tetes
saison["cadrage"] = 100.0 * saison.cadres / saison.tetes
saison["ci_low"], saison["ci_high"] = zip(
    *[wilson(int(b), int(t)) for b, t in zip(saison.buts, saison.tetes)])
saison["ci_low"] *= 100.0
saison["ci_high"] *= 100.0

masques = [
    h.dist <= 5.5,
    (h.dist > 5.5) & (h.dist <= 8.3),
    (h.dist > 8.3) & (h.dist <= 16.5),
    h.dist > 16.5,
]
libelles = ["≤ 5,5 m", "5,5–8,3 m", "8,3–16,5 m", "> 16,5 m"]
distance = []
for masque, libelle in zip(masques, libelles):
    part = h[masque]
    distance.append({
        "label": libelle, "n": int(len(part)), "part": 100.0 * len(part) / n,
        "buts": int(part.is_goal.sum()), "conversion": 100.0 * float(part.is_goal.mean()),
    })
assert sum(d["n"] for d in distance) == n
mediane = float(h.dist.median())
part_mediane = 100.0 * float((h.dist <= mediane).mean())

cadre = h[h.outcome_raw.isin(["Goal", "SavedShot", "ShotOnPost"])].dropna(
    subset=["goal_mouth_y", "goal_mouth_z"]).copy()
cadre["col"] = np.select(
    [cadre.goal_mouth_y < 47.5, cadre.goal_mouth_y > 52.5], ["Droite", "Gauche"], default="Axe")
cadre["row"] = np.select(
    [cadre.goal_mouth_z < 10, cadre.goal_mouth_z > 22], ["Bas", "Haut"], default="Mi-hauteur")
grille = []
for row in ["Haut", "Mi-hauteur", "Bas"]:
    for col in ["Droite", "Axe", "Gauche"]:
        cellule = cadre[(cadre.row == row) & (cadre.col == col)]
        grille.append({
            "row": row, "col": col, "n": int(len(cellule)),
            "part": 100.0 * len(cellule) / len(cadre),
            "conversion": 100.0 * float(cellule.is_goal.mean()),
        })
axe_part = 100.0 * float((cadre.col == "Axe").mean())
axe_conv = 100.0 * float(cadre.loc[cadre.col == "Axe", "is_goal"].mean())
cote_conv = 100.0 * float(cadre.loc[cadre.col != "Axe", "is_goal"].mean())

assistes = h[h.assist_valid].copy()
livraisons = (
    assistes.groupby("delivery")
    .agg(tetes=("is_goal", "size"), buts=("is_goal", "sum"))
    .reset_index()
)
livraisons["part"] = 100.0 * livraisons.tetes / len(assistes)
livraisons["conversion"] = 100.0 * livraisons.buts / livraisons.tetes
livraisons = livraisons.sort_values("tetes", ascending=False).reset_index(drop=True)
corner = livraisons.set_index("delivery").loc["Corner"]
cross = livraisons.set_index("delivery").loc["Open-play cross"]
p1, p2 = corner.conversion / 100.0, cross.conversion / 100.0
p_pool = (corner.buts + cross.buts) / (corner.tetes + cross.tetes)
se = np.sqrt(p_pool * (1 - p_pool) * (1 / corner.tetes + 1 / cross.tetes))
p_corner_cross = float(2 * (1 - norm.cdf(abs((p1 - p2) / se))))

championnats = (
    h.groupby("league").agg(tetes=("is_goal", "size"), buts=("is_goal", "sum")).reset_index())
championnats["conversion"] = 100.0 * championnats.buts / championnats.tetes
p_ligues = float(chi2_contingency(pd.crosstab(h.league, h.is_goal), correction=False)[1])
serie = h[h.league == "Serie A"].groupby("season").agg(tetes=("is_goal", "size"), buts=("is_goal", "sum"))
serie["conversion"] = 100.0 * serie.buts / serie.tetes
serie_first, serie_last = float(serie.conversion.iloc[0]), float(serie.conversion.iloc[-1])

p = (
    assistes.groupby("assist_player_id")
    .agg(tetes=("is_goal", "size"), buts=("is_goal", "sum")).reset_index()
)
p = p.merge(passeurs[["assist_player_id", "assist_player"]], on="assist_player_id", how="left")
assert p.assist_player.notna().all()
p["conversion"] = 100.0 * p.buts / p.tetes
passeurs_n = int(p.assist_player_id.nunique())
verif_p = passeurs.set_index("assist_player_id").join(p.set_index("assist_player_id")[["tetes", "buts"]])
assert (verif_p.headers == verif_p.tetes).all() and (verif_p.goals == verif_p.buts).all()
top_pourvoyeurs = p.sort_values(["buts", "tetes"], ascending=False).head(10).reset_index(drop=True)
rendement = p[p.tetes >= 150].sort_values(["conversion", "tetes"], ascending=False).reset_index(drop=True)
assert rendement.iloc[0].assist_player == "Christian Fuchs"
fuchs = p[p.assist_player == "Christian Fuchs"].iloc[0]

b = h.groupby("player_id").agg(tetes=("is_goal", "size"), buts=("is_goal", "sum")).reset_index()
b = b.merge(joueurs[["player_id", "player"]], on="player_id", how="left")
assert b.player.notna().all()
verif_j = joueurs.set_index("player_id").join(b.set_index("player_id")[["tetes", "buts"]])
assert (verif_j.headers == verif_j.tetes).all() and (verif_j.goals == verif_j.buts).all()
b["conversion"] = 100.0 * b.buts / b.tetes
buteurs = b[b.tetes >= 100].sort_values(["buts", "tetes"], ascending=False).head(10).reset_index(drop=True)
kane = b[b.player == "Harry Kane"].iloc[0]

c = h.groupby("team_id").agg(tetes=("is_goal", "size"), buts=("is_goal", "sum")).reset_index()
c = c.merge(equipes, on="team_id", how="left")
assert c.team.notna().all()
c["conversion"] = 100.0 * c.buts / c.tetes
top_clubs = c.sort_values(["buts", "tetes"], ascending=False).head(5).reset_index(drop=True)
sochaux = c[c.team == "Sochaux"].iloc[0]

slope, intercept, _, p_conv, _ = linregress(saison.season_start, saison.conversion)
print(f"{n} têtes · {buts} buts · {conversion:.2f} % · {len(cadre)} têtes localisées")
print(f"saison : {saison.tetes_par_match.iloc[0]:.2f} -> {saison.tetes_par_match.iloc[-1]:.2f} têtes/match")
print(f"conversion : {saison.conversion.iloc[0]:.1f} % -> {saison.conversion.iloc[-1]:.1f} %")
print(f"pente {slope * 10:+.2f} pt / 10 ans · p = {p_conv:.2f}")
print(f"pourvoyeurs : {len(assistes)} têtes assistées · {passeurs_n} identifiants")

def r1(x):
    return round(float(x) + 1e-9, 1)


def r2(x):
    return round(float(x) + 1e-9, 2)


assert n == 131531 and buts == 13921
assert r1(conversion) == 10.6
assert r1(part_buts) == 17.0 and r1(part_tirs) == 16.8
assert r1(cadrage) == 43.1 and r1(cadrage_pied) == 62.4
assert r1(conversion_pied) == 10.4
assert r1(conversion_cadrees) == 24.5 and r1(conversion_cadrees_pied) == 16.7
assert r2(saison.tetes.sum() / saison.matchs.sum()) == 4.29
assert r2(saison.tetes_par_match.iloc[0]) == 4.32 and r2(saison.tetes_par_match.iloc[-1]) == 4.52
assert r1(saison.conversion.iloc[0]) == 11.4 and r1(saison.conversion.iloc[-1]) == 9.5
assert r1(mediane) == 8.3 and r1(part_mediane) == 50.2
assert r1(distance[0]["conversion"]) == 21.6 and r1(distance[3]["conversion"]) == 1.9
assert r1(axe_part) == 58.2 and r1(axe_conv) == 16.1 and r1(cote_conv) == 41.0
assert r1(corner.part) == 34.8 and r1(corner.conversion) == 9.8 and r1(cross.conversion) == 10.0
assert round(p_corner_cross, 2) == 0.26
assert len(assistes) == 124931 and passeurs_n == 7258
assert tuple(int(v) for v in top_pourvoyeurs.buts.head(3)) == (50, 47, 39)
assert r1(fuchs.conversion) == 16.1 and int(fuchs.tetes) == 161
assert r1(kane.conversion) == 21.0 and int(kane.tetes) == 267
assert tuple(int(v) for v in buteurs.buts.head(3)) == (67, 62, 56)
assert tuple(int(v) for v in top_clubs.buts.head(3)) == (232, 230, 203)
assert r1(sochaux.conversion) == 16.0 and int(sochaux.tetes) == 357
assert r1(championnats.conversion.min()) == 10.2 and r1(championnats.conversion.max()) == 11.0
assert round(p_ligues, 2) == 0.10
assert r1(serie_first) == 12.4 and r1(serie_last) == 8.8
print("OK : 16 chiffres publiés retrouvés")

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap, Normalize
from matplotlib.patches import Rectangle

CHARTS = Path("preuves/out/graphiques")
CHARTS.mkdir(parents=True, exist_ok=True)
DARK, TEXT, MUTED, GRID = "#081420", "#e8eef2", "#9fb0bd", "#223442"
LIME, BLUE, CORAL, GOLD = "#c7ff5e", "#6cb6ff", "#ff7a7a", "#ffd166"
plt.rcParams.update({
    "font.family": "DejaVu Sans",
    "text.color": TEXT,
    "axes.labelcolor": MUTED,
    "xtick.color": MUTED,
    "ytick.color": MUTED,
    "axes.edgecolor": GRID,
    "axes.facecolor": DARK,
    "figure.facecolor": DARK,
    "savefig.facecolor": DARK,
})


def fr(x, d=1):
    return f"{x:.{d}f}".replace(".", ",")


def finir(fig, ax, titre, sous_titre=None):
    ax.set_title(titre, loc="left", color=TEXT, fontsize=15, fontweight="bold", pad=18)
    if sous_titre:
        fig.text(0.01, 0.94, sous_titre, color=MUTED, fontsize=9, ha="left")
    ax.grid(color=GRID, linewidth=.6, alpha=.65)
    ax.set_axisbelow(True)
    for cote in ("top", "right"):
        ax.spines[cote].set_visible(False)


fig, axes = plt.subplots(1, 2, figsize=(12.6, 4.5))
x = np.arange(len(saison))
axes[0].plot(x, saison.tetes_par_match, color=BLUE, linewidth=2.4, marker="o", markersize=4)
moyenne = saison.tetes.sum() / saison.matchs.sum()
axes[0].axhline(moyenne, color=MUTED, linewidth=1, linestyle="--")
axes[0].text(len(saison) - 1, moyenne + .06, f"moyenne {fr(moyenne, 2)}",
             color=MUTED, fontsize=8.5, ha="right")
axes[0].set_ylabel("têtes / match")
axes[0].set_xticks(x[::2])
axes[0].set_xticklabels(saison.label[::2], fontsize=8.5)
axes[0].set_ylim(saison.tetes_par_match.min() - .12, saison.tetes_par_match.max() + .12)
finir(fig, axes[0], "Le volume ne bouge pas")

axes[1].errorbar(x, saison.conversion,
                 yerr=[saison.conversion - saison.ci_low, saison.ci_high - saison.conversion],
                 fmt="o", color=CORAL, ecolor=GRID, elinewidth=1.3, markersize=4.5, capsize=0)
axes[1].plot(x, intercept + slope * saison.season_start, color=GOLD, linewidth=1.8, linestyle="--")
axes[1].set_ylabel("buts / têtes (%)")
axes[1].set_xticks(x[::2])
axes[1].set_xticklabels(saison.label[::2], fontsize=8.5)
axes[1].set_ylim(saison.conversion.min() - .7, saison.conversion.max() + .7)
p_txt = "< 0,001" if p_conv < .001 else f"{p_conv:.2f}".replace(".", ",")
pente_txt = f"{slope * 10:+.1f}".replace(".", ",")
axes[1].text(.02, .07, f"pente {pente_txt} pt / 10 ans · p {p_txt}",
             transform=axes[1].transAxes, color=GOLD, fontsize=8.5)
finir(fig, axes[1], "La réussite recule")
fig.text(.01, .955, "131 531 têtes · 2009/10–2025/26 · moyenne 4,29 par match · IC 95 % de Wilson",
         color=MUTED, fontsize=9, ha="left")
fig.tight_layout(rect=(0, 0, 1, .91))
fig.savefig(CHARTS / "21-volume-conversion.png", dpi=160, bbox_inches="tight")
plt.close(fig)

fig, ax = plt.subplots(figsize=(8.6, 4.4))
positions = np.arange(len(distance))
barres = ax.barh(positions, [d["conversion"] for d in distance], color=[LIME, BLUE, CORAL, "#b28cff"],
                 height=.6)
ax.invert_yaxis()
ax.set_yticks(positions)
ax.set_yticklabels([d["label"] for d in distance])
ax.set_xlim(0, 27)
ax.set_xlabel("taux de réussite (%)")
for barre, d in zip(barres, distance):
    n_txt = f"{d['n']:,}".replace(",", " ")
    ax.text(barre.get_width() + .5, barre.get_y() + barre.get_height() / 2,
            f"{fr(d['conversion'])} % · {n_txt} têtes",
            va="center", color=TEXT, fontsize=8.5)
finir(fig, ax, "La réussite chute avec la distance",
      f"médiane {mediane:.1f} m · {part_mediane:.1f} % des têtes à {mediane:.1f} m ou moins".replace(".", ","))
fig.subplots_adjust(top=.80, left=.18, right=.96, bottom=.18)
fig.savefig(CHARTS / "21-distance.png", dpi=160, bbox_inches="tight")
plt.close(fig)

fig, ax = plt.subplots(figsize=(8.8, 4.8))
colonnes = ["Droite", "Axe", "Gauche"]
lignes = ["Haut", "Mi-hauteur", "Bas"]
part_max = max(g["part"] for g in grille) / 100
cmap = LinearSegmentedColormap.from_list("cadre", ["#0e1a2c", "#133b66", "#2f7cc4", "#ffd166"])
norm = Normalize(vmin=0, vmax=part_max)
for g in grille:
    i, j = lignes.index(g["row"]), colonnes.index(g["col"])
    couleur = cmap(norm(g["part"] / 100))
    lum = .2126 * couleur[0] + .7152 * couleur[1] + .0722 * couleur[2]
    fg = DARK if lum > .55 else TEXT
    ax.add_patch(Rectangle((j, -i), .97, .97, facecolor=couleur, edgecolor=DARK, linewidth=2))
    ax.text(j + .485, -i + .62, f"{fr(g['part'])} %", ha="center", va="center",
            fontsize=15, fontweight="bold", color=fg)
    ax.text(j + .485, -i + .28, f"{fr(g['conversion'])} % de buts", ha="center", va="center",
            fontsize=8.5, color=fg)
ax.set_xlim(-.1, 3.05)
ax.set_ylim(-2.12, 1.15)
ax.set_xticks([j + .485 for j in range(3)])
ax.set_xticklabels(colonnes)
ax.xaxis.tick_top()
ax.set_yticks([-i + .485 for i in range(3)])
ax.set_yticklabels(lignes)
ax.set_title("Où vont les têtes cadrées", loc="left", color=TEXT, fontsize=15, fontweight="bold", pad=32)
ax.tick_params(length=0)
ax.grid(False)
for cote in ax.spines.values():
    cote.set_visible(False)
fig.text(.01, .93, f"Part des {len(cadre):,} têtes cadrées localisées · réussite dans chaque zone".replace(",", " "),
         color=MUTED, fontsize=9, ha="left")
fig.subplots_adjust(top=.77, left=.10, right=.98, bottom=.10)
fig.savefig(CHARTS / "21-cadre.png", dpi=160, bbox_inches="tight")
plt.close(fig)

fig, ax = plt.subplots(figsize=(8.8, 5.2))
top = top_pourvoyeurs.iloc[::-1]
positions = np.arange(len(top))
barres = ax.barh(positions, top.buts, color=LIME, height=.62)
ax.set_yticks(positions)
ax.set_yticklabels(top.assist_player, fontsize=9)
ax.set_xlim(0, 58)
ax.set_xlabel("buts inscrits sur une tête délivrée")
for barre, ligne in zip(barres, top.itertuples()):
    ax.text(barre.get_width() + .9, barre.get_y() + barre.get_height() / 2,
            f"{int(ligne.buts)} buts · {fr(ligne.conversion)} %",
            va="center", color=TEXT, fontsize=8.5)
finir(fig, ax, "Les meilleurs pourvoyeurs",
      "Buts marqués sur leurs têtes · 124 931 têtes assistées")
fig.subplots_adjust(top=.80, left=.24, right=.96, bottom=.18)
fig.savefig(CHARTS / "21-pourvoyeurs.png", dpi=160, bbox_inches="tight")
plt.close(fig)

print("graphiques : preuves/out/graphiques/21-*.png")

assertions_ok = [
    "131 531 têtes retenues, 486 CSC exclus, sur 17 saisons et cinq ligues",
    "13 921 buts : 10,6 % de réussite et 17,0 % des 81 860 buts du Big 5",
    "la tête pèse 16,8 % des tirs ; 43,1 % cadrées contre 62,4 % pour le pied",
    "10,6 % contre 10,4 % : la tête convertit comme un tir du pied",
    "une tête cadrée finit au fond à 24,5 %, un tir cadré du pied à 16,7 %",
    "4,29 têtes par match en moyenne ; 4,32 en 2009/10, 4,52 en 2025/26",
    "la réussite recule de 11,4 % à 9,5 % entre 2009/10 et 2025/26",
    "distance médiane 8,3 m ; 50,2 % des têtes à 8,3 m ou moins",
    "21,6 % de réussite à 5,5 m ou moins, 1,9 % au-delà de 16,5 m",
    "58,2 % des têtes cadrées visent l'axe ; 16,1 % dans l'axe contre 41,0 % sur les côtés",
    "corners : 34,8 % des têtes assistées, 9,8 % de réussite contre 10,0 % pour les centres (p = 0,26)",
    "124 931 têtes assistées et 7 258 identifiants de passeur ; Payet 50 buts, Kroos 47, Çalhanoğlu 39",
    "Fuchs 16,1 % sur 161 têtes ; Kane 21,0 % sur 267 têtes",
    "buteurs : Ronaldo 67, Lewandowski 62, Kane 56 buts de la tête",
    "clubs : Real Madrid 232, Bayern 230, Inter 203 ; Sochaux 16,0 % sur 357 têtes",
    "championnats : 10,2–11,0 % (p = 0,10) ; Serie A de 12,4 % à 8,8 %",
]
non_verifie = [
    "la ligne « Pied » de la comparaison tête / pied est un agrégat de contrôle, "
    "non recalculé ligne à ligne dans ce notebook",
]

payload = {
    "etude": "21",
    "statut": "exécuté",
    "niveau": "recalcul · agrégats (volume, distance, cadre, livraisons, joueurs)",
    "genere_le": datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds"),
    "environnement": {
        "python": platform.python_version(),
        "pandas": pd.__version__,
        "numpy": np.__version__,
        "scipy": __import__("scipy").__version__,
    },
    "entrees": {
        nom: {
            "sha256": hashlib.sha256((RACINE / nom).read_bytes()).hexdigest(),
            "octets": (RACINE / nom).stat().st_size,
        }
        for nom in ENTREES
    },
    "chiffres": {
        "tetes": n,
        "buts": buts,
        "conversion": conversion,
        "tirs": int(perimetre["tirs_2009_2026"]),
        "tirs_archive": int(perimetre["tirs_archive"]),
        "buts_big5": int(perimetre["buts_big5"]),
        "part_tirs": part_tirs,
        "part_buts": part_buts,
        "csc": int(perimetre["tetes_csc"]),
        "matchs": int(perimetre["matchs"]),
        "saisons": 17,
        "ligues": 5,
        "cadrage": cadrage,
        "conversion_cadrees": conversion_cadrees,
        "tete_pied": {
            "Tete": {
                "tirs": int(tete["tirs"]), "buts": int(tete["buts"]),
                "cadres": int(tete["cadres"]), "conversion": conversion,
                "cadrage": cadrage, "conversion_cadres": conversion_cadrees,
            },
            "Pied": {
                "tirs": int(pied["tirs"]), "buts": int(pied["buts"]),
                "cadres": int(pied["cadres"]), "conversion": conversion_pied,
                "cadrage": cadrage_pied, "conversion_cadres": conversion_cadrees_pied,
            },
        },
        "repartition_buts": {"tete": buts, "autres": int(perimetre["buts_big5"]) - buts},
        "saison": [
            {
                "season": row.season, "matchs": int(row.matchs), "tetes": int(row.tetes),
                "buts": int(row.buts), "tetes_par_match": float(row.tetes_par_match),
                "conversion": float(row.conversion), "cadrage": float(row.cadrage),
                "ci_low": float(row.ci_low), "ci_high": float(row.ci_high),
            }
            for row in saison.itertuples()
        ],
        "distance": {"mediane": mediane, "part_mediane": part_mediane, "bandes": distance},
        "cadre": {
            "n": len(cadre), "axe_part": axe_part,
            "axe_conversion": axe_conv, "cote_conversion": cote_conv, "grille": grille,
        },
        "livraisons": [
            {
                "livraison": row.delivery, "tetes": int(row.tetes), "buts": int(row.buts),
                "part": float(row.part), "conversion": float(row.conversion),
            }
            for row in livraisons.itertuples()
        ],
        "championnats": [
            {
                "league": row.league, "tetes": int(row.tetes), "buts": int(row.buts),
                "conversion": float(row.conversion),
            }
            for row in championnats.itertuples()
        ],
        "p_ligues": p_ligues,
        "p_corner_cross": p_corner_cross,
        "pourvoyeurs": {
            "tetes_assistees": len(assistes),
            "passeurs": passeurs_n,
            "top": [
                {
                    "joueur": row.assist_player, "tetes": int(row.tetes),
                    "buts": int(row.buts), "conversion": float(row.conversion),
                }
                for row in top_pourvoyeurs.itertuples()
            ],
        },
        "buteurs": {
            "top": [
                {
                    "joueur": row.player, "tetes": int(row.tetes),
                    "buts": int(row.buts), "conversion": float(row.conversion),
                }
                for row in buteurs.itertuples()
            ],
        },
        "clubs": {
            "top": [
                {
                    "club": row.team, "tetes": int(row.tetes),
                    "buts": int(row.buts), "conversion": float(row.conversion),
                }
                for row in top_clubs.itertuples()
            ],
        },
    },
    "assertions_ok": assertions_ok,
    "non_verifie": non_verifie,
}
SORTIE.mkdir(parents=True, exist_ok=True)
(SORTIE / "21.json").write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
print("écrit : preuves/out/21.json")

from preuves.graphiques_densite import generer_densite

generer_densite("21")