| """Urgence mathématique (CE) - ISO 5055/5259. |
| |
| Ce module calcule l'urgence mathématique pour le Composition Engine. |
| Détermine si les objectifs sont encore atteignables mathématiquement. |
| |
| Features (DOCUMENTÉES ISO 5259): |
| - montee_possible: bool - L'équipe peut-elle encore monter? |
| Calcul: points_actuels + (rondes_restantes * 2) >= points_1er |
| - maintien_assure: bool - L'équipe ne peut plus descendre? |
| Calcul: points_actuels > points_releguable + (rondes_restantes * 2) |
| - urgence_level: Classification de l'urgence |
| - 'critique': Dernier match pour sauver objectif |
| - 'haute': 2-3 matchs pour atteindre objectif |
| - 'normale': Situation contrôlée |
| - 'aucune': Objectif assuré ou abandonné |
| |
| Justification calculs: |
| - 2 pts max par match (victoire) |
| - Formule standard de mathématiques sportives |
| |
| Conformité: |
| - ISO 5055: Module <300 lignes, responsabilité unique |
| - ISO 5259: Features depuis données réelles, calculs documentés |
| """ |
|
|
| from __future__ import annotations |
|
|
| import logging |
|
|
| import pandas as pd |
|
|
| logger = logging.getLogger(__name__) |
|
|
|
|
| def calculate_urgency_features( |
| standings: pd.DataFrame, |
| ronde_actuelle: int, |
| nb_rondes_total: int = 9, |
| ) -> pd.DataFrame: |
| """Calcule l'urgence mathématique par équipe. |
| |
| Args: |
| ---- |
| standings: DataFrame classement avec colonnes: |
| - equipe, position, points_cumules, nb_equipes |
| ronde_actuelle: Numéro de la ronde actuelle |
| nb_rondes_total: Nombre total de rondes (défaut: 9 pour interclubs) |
| |
| Returns: |
| ------- |
| DataFrame avec colonnes: |
| - equipe: nom équipe |
| - saison: saison concernée |
| - montee_possible: bool |
| - maintien_assure: bool |
| - rondes_restantes: int |
| - urgence_level: 'critique', 'haute', 'normale', 'aucune' |
| - points_max_possibles: int (points actuels + max restant) |
| |
| ISO 5259: Urgence calculée depuis mathématiques du classement. |
| """ |
| logger.info(f"Calcul urgence mathématique (ronde {ronde_actuelle}/{nb_rondes_total})...") |
|
|
| if standings.empty: |
| return pd.DataFrame() |
|
|
| rondes_restantes = max(0, nb_rondes_total - ronde_actuelle) |
| points_max_restants = rondes_restantes * 2 |
|
|
| |
| points_premier = standings["points_cumules"].max() if not standings.empty else 0 |
|
|
| |
| standings_sorted = standings.sort_values("points_cumules", ascending=True) |
| if len(standings_sorted) >= 2: |
| points_releguable = standings_sorted.iloc[1]["points_cumules"] |
| else: |
| points_releguable = 0 |
|
|
| urgency_data = [] |
|
|
| for _, row in standings.iterrows(): |
| equipe = row["equipe"] |
| saison = row.get("saison", 2025) |
| points = row["points_cumules"] |
| position = row["position"] |
| nb_equipes = row["nb_equipes"] |
|
|
| |
| points_max = points + points_max_restants |
|
|
| |
| |
| montee_possible = points_max >= points_premier or position <= 2 |
|
|
| |
| |
| if position <= nb_equipes - 2: |
| |
| marge = points - points_releguable |
| maintien_assure = marge > points_max_restants |
| else: |
| |
| maintien_assure = False |
|
|
| |
| urgence = _classify_urgency( |
| rondes_restantes=rondes_restantes, |
| montee_possible=montee_possible, |
| maintien_assure=maintien_assure, |
| position=position, |
| nb_equipes=nb_equipes, |
| ecart_premier=row.get("ecart_premier", 0), |
| ecart_dernier=row.get("ecart_dernier", 0), |
| ) |
|
|
| urgency_data.append( |
| { |
| "equipe": equipe, |
| "saison": saison, |
| "ronde": ronde_actuelle, |
| "position": position, |
| "points_cumules": points, |
| "montee_possible": montee_possible, |
| "maintien_assure": maintien_assure, |
| "rondes_restantes": rondes_restantes, |
| "points_max_possibles": points_max, |
| "urgence_level": urgence, |
| } |
| ) |
|
|
| result = pd.DataFrame(urgency_data) |
| logger.info(f" {len(result)} équipes avec urgence mathématique") |
| return result |
|
|
|
|
| def _classify_urgency( |
| rondes_restantes: int, |
| montee_possible: bool, |
| maintien_assure: bool, |
| position: int, |
| nb_equipes: int, |
| ecart_premier: int, |
| ecart_dernier: int, |
| ) -> str: |
| """Classifie le niveau d'urgence. |
| |
| Classification (DOCUMENTÉE ISO 5259): |
| - 'critique': Dernière ronde + objectif en jeu (maintien ou montée) |
| - 'haute': 2-3 rondes restantes + situation tendue |
| - 'normale': Situation contrôlée |
| - 'aucune': Objectif assuré ou hors course |
| |
| Returns |
| ------- |
| Niveau d'urgence: 'critique', 'haute', 'normale', 'aucune' |
| """ |
| if maintien_assure and position > 4: |
| return "aucune" |
|
|
| en_danger = _is_in_danger(maintien_assure, position, nb_equipes, ecart_dernier) |
| en_course = _is_in_race(montee_possible, position, ecart_premier) |
|
|
| if rondes_restantes <= 1 and (en_danger or en_course): |
| return "critique" |
|
|
| if rondes_restantes <= 3 and (en_danger or en_course): |
| return "haute" |
|
|
| return "normale" |
|
|
|
|
| def _is_in_danger( |
| maintien_assure: bool, position: int, nb_equipes: int, ecart_dernier: int |
| ) -> bool: |
| """Determine si l'equipe est en danger de relegation.""" |
| if maintien_assure: |
| return False |
| return position > nb_equipes - 2 or ecart_dernier <= 2 |
|
|
|
|
| def _is_in_race(montee_possible: bool, position: int, ecart_premier: int) -> bool: |
| """Determine si l'equipe est en course pour la montee.""" |
| if montee_possible and position <= 2: |
| return True |
| return ecart_premier <= 2 and position <= 4 |
|
|
