| """Patterns de sélection (ALI) - ISO 5055/5259. |
| |
| Ce module calcule les patterns de sélection des joueurs |
| pour prédire leur présence future. |
| |
| Features (DOCUMENTÉES ISO 5259): |
| - role_type: Classification du rôle dans l'équipe |
| - 'titulaire': Joue > 70% des rondes, position stable |
| - 'rotation': Joue 30-70% des rondes, rotation régulière |
| - 'remplacant': Joue < 30% des rondes, utilisé ponctuellement |
| - 'polyvalent': Joue sur plusieurs échiquiers différents (std > 2) |
| - echiquier_prefere: Échiquier modal (le plus fréquent) |
| - flexibilite_echiquier: Écart-type des positions jouées |
| - 0: Toujours même échiquier |
| - > 2: Très flexible, peut jouer partout |
| |
| Justification seuils: |
| - 70%/30%: Même seuils que regularité (cohérence) |
| - std > 2: Un joueur jouant éch. 1-5 régulièrement = polyvalent |
| |
| Conformité: |
| - ISO 5055: Module <300 lignes, responsabilité unique |
| - ISO 5259: Features depuis données réelles, seuils documentés |
| """ |
|
|
| from __future__ import annotations |
|
|
| import logging |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| logger = logging.getLogger(__name__) |
|
|
|
|
| def calculate_selection_patterns(df: pd.DataFrame) -> pd.DataFrame: |
| """Calcule les patterns de sélection par joueur. |
| |
| Args: |
| ---- |
| df: DataFrame échiquiers avec colonnes joueur, echiquier, ronde |
| |
| Returns: |
| ------- |
| DataFrame avec colonnes: |
| - joueur_nom: nom joueur |
| - saison: saison concernée |
| - role_type: 'titulaire', 'remplacant', 'polyvalent' |
| - echiquier_prefere: int (échiquier modal) |
| - flexibilite_echiquier: float (std positions) |
| - nb_echiquiers_differents: int |
| |
| ISO 5259: Patterns calculés depuis compositions réelles. |
| """ |
| logger.info("Calcul patterns sélection joueur...") |
|
|
| if df.empty or "echiquier" not in df.columns: |
| return pd.DataFrame() |
|
|
| pattern_data = [] |
|
|
| for saison in df["saison"].unique(): |
| df_saison = df[df["saison"] == saison] |
| nb_rondes_total = df_saison["ronde"].nunique() |
| if nb_rondes_total == 0: |
| continue |
|
|
| for couleur in ["blanc", "noir"]: |
| _process_color_patterns(df_saison, couleur, saison, nb_rondes_total, pattern_data) |
|
|
| return _deduplicate_patterns(pattern_data) |
|
|
|
|
| def _process_color_patterns( |
| df_saison: pd.DataFrame, |
| couleur: str, |
| saison: int, |
| nb_rondes_total: int, |
| pattern_data: list[dict], |
| ) -> None: |
| """Traite les patterns pour une couleur donnee.""" |
| nom_col = f"{couleur}_nom" |
| if nom_col not in df_saison.columns: |
| return |
|
|
| for joueur, group in df_saison.groupby(nom_col): |
| pattern = _analyze_player_pattern(joueur, group, saison, nb_rondes_total) |
| pattern_data.append(pattern) |
|
|
|
|
| def _analyze_player_pattern( |
| joueur: str, |
| group: pd.DataFrame, |
| saison: int, |
| nb_rondes_total: int, |
| ) -> dict: |
| """Analyse le pattern d'un joueur.""" |
| echiquiers = group["echiquier"].tolist() |
| nb_rondes_jouees = group["ronde"].nunique() |
| nb_echiquiers_diff = len(set(echiquiers)) |
|
|
| echiquier_prefere = pd.Series(echiquiers).value_counts().index[0] |
| flexibilite = float(np.std(echiquiers)) if len(echiquiers) > 1 else 0.0 |
| taux_presence = nb_rondes_jouees / nb_rondes_total |
|
|
| role = _classify_role(flexibilite, nb_echiquiers_diff, taux_presence) |
|
|
| return { |
| "joueur_nom": joueur, |
| "saison": saison, |
| "role_type": role, |
| "echiquier_prefere": int(echiquier_prefere), |
| "flexibilite_echiquier": round(flexibilite, 2), |
| "nb_echiquiers_differents": nb_echiquiers_diff, |
| "taux_presence": round(taux_presence, 3), |
| } |
|
|
|
|
| def _classify_role(flexibilite: float, nb_echiquiers_diff: int, taux_presence: float) -> str: |
| """Classifie le role du joueur.""" |
| if flexibilite > 2 and nb_echiquiers_diff >= 3: |
| return "polyvalent" |
| if taux_presence > 0.7: |
| return "titulaire" |
| if taux_presence < 0.3: |
| return "remplacant" |
| return "rotation" |
|
|
|
|
| def _deduplicate_patterns(pattern_data: list[dict]) -> pd.DataFrame: |
| """Deduplique les patterns par joueur/saison.""" |
| result = pd.DataFrame(pattern_data) |
| if result.empty: |
| return result |
|
|
| result = ( |
| result.groupby(["joueur_nom", "saison"]) |
| .agg( |
| role_type=("role_type", "first"), |
| echiquier_prefere=("echiquier_prefere", lambda x: int(pd.Series(x).mode().iloc[0])), |
| flexibilite_echiquier=("flexibilite_echiquier", "max"), |
| nb_echiquiers_differents=("nb_echiquiers_differents", "max"), |
| taux_presence=("taux_presence", "max"), |
| ) |
| .reset_index() |
| ) |
|
|
| logger.info(f" {len(result)} joueurs avec patterns sélection") |
| return result |
|
|
