Upload code/scripts/features/ce/urgency.py with huggingface_hub

code/scripts/features/ce/urgency.py

@@ -0,0 +1,186 @@
+"""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  # 2 pts par victoire
+
+    # Calculer points du 1er et du relégable
+    points_premier = standings["points_cumules"].max() if not standings.empty else 0
+
+    # Relégable = avant-dernier ou dernier selon nb équipes
+    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 possibles
+        points_max = points + points_max_restants
+
+        # Montée possible?
+        # Peut-on atteindre ou dépasser le 1er?
+        montee_possible = points_max >= points_premier or position <= 2
+
+        # Maintien assuré?
+        # Est-on suffisamment au-dessus du relégable?
+        if position <= nb_equipes - 2:
+            # Pas en zone rouge
+            marge = points - points_releguable
+            maintien_assure = marge > points_max_restants
+        else:
+            # En zone rouge
+            maintien_assure = False
+
+        # Niveau d'urgence
+        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