Mode Validation : Architecture et Fonctionnalités Avancées

{
  "1": [
    {
      "coeff": 1.0,
      "type": "wc-automaton-editor",
      "theme": "Théorie des langages",
      "title": "Reconnaissance de motif simple",
      "statement": "Créez un automate fini qui accepts toutes les chaînes sur l'alphabet {a, b} commençant impérativement par la lettre 'a' et se terminant par la lettre 'b'.",
      "countdownTime": 180,
      "automaton": {
        "states": ["s0", "s1", "s2"],
        "initialStates": ["s0"],
        "acceptingStates": ["s2"],
        "alphabet": ["a", "b"],
        "transitions": [],
        "position": {
          "s0": {"x": 100, "y": 250},
          "s1": {"x": 300, "y": 250},
          "s2": {"x": 500, "y": 250}
        }
      },
      "solution": {
        "states": ["s0", "s1", "s2"],
        "initialStates": ["s0"],
        "acceptingStates": ["s2"],
        "alphabet": ["a", "b"],
        "transitions": [
          {"fromState": "s0", "toState": "s1", "symbols": ["a"]},
          {"fromState": "s1", "toState": "s1", "symbols": ["a", "b"]},
          {"fromState": "s1", "toState": "s2", "symbols": ["b"]}
        ],
        "position": {
          "s0": {"x": 100, "y": 250},
          "s1": {"x": 300, "y": 250},
          "s2": {"x": 500, "y": 250}
        }
      },
      "bareme": "lambda student_automaton, soluce_automaton: (lambda s, c: (lambda states_score: states_score + (20 if s['initialStates'] == c['initialStates'] else 0) + (20 if set(s['acceptingStates']) == set(c['acceptingStates']) else 0) + (lambda stu_trans, sol_trans: (lambda matches: (len(matches) / len(sol_trans) * 30) if len(sol_trans) > 0 else 0)(set((t['fromState'], t['toState'], tuple(sorted(t['symbols']))) for t in stu_trans).intersection(set((t['fromState'], t['toState'], tuple(sorted(t['symbols']))) for t in sol_trans))))(s['transitions'], c['transitions']))(30 if set(s['states']) == set(c['states']) else 0))(student_automaton, soluce_automaton)",
      "explication": "Pour valider une chaîne commençant par 'a' et finissant par 'b' : 1. L'état initial s0 doit consommer un 'a' pour transiter vers s1. 2. L'état s1 possède une boucle réflexive pour lire tous les symboles intermédiaires. 3. Dès qu'un 'b' est rencontré en fin de chaîne, l'automate bascule vers s2 (état acceptant).",
      "feedbacks": {
        "correct": "Votre automate filtre parfaitement le langage demandé.",
        "partial": "C'est un bon début. Vérifiez que votre alphabet comporte toutes les transitions requises.",
        "incorrect": "La logique n'est pas correcte. Relisez attentivement la consigne."
      }
    }
  ],
  "2": [
    {
      "coeff": 1.0,
      "type": "wc-word-selector",
      "theme": "Histoire - Monarchie",
      "title": "Le premier roi des Francs",
      "assignment": "Retrouvez le nom du premier roi des Francs à s'être fait baptiser.",
      "words": ["Clovis", "Ier", "Charlemagne", "Childebert", "Baptême"],
      "selectedWords": ["Clovis", "Ier"],
      "explication": "Clovis Ier est historiquement considéré comme le premier roi des Francs chrétien à la suite de son baptême dans la cathédrale de Reims.",
      "bareme": "lambda student_words, soluce_words: 100 if set(student_words) == set(soluce_words) else max(0, 100 - (len(set(student_words) ^ set(soluce_words)) * 33))",
      "feedbacks": {
        "correct": "Vous avez correctement identifié le souverain.",
        "partial": "Votre sélection de mots est incomplète ou contient un intrus.",
        "incorrect": "Ce souverain ne correspond pas au premier roi des Francs baptisé."
      }
    },
    {
      "coeff": 1.0,
      "type": "wc-drag-drop",
      "theme": "Histoire - Chronologie",
      "title": "Grandes dates de l'histoire",
      "assignment": "Associez chaque événement historique marquant à sa date correspondante.",
      "nbq": 4,
      "listofvalues": [
        {"content": "Chute de l'Empire romain d'Occident", "correct": "476", "explication": "Cet événement marque traditionnellement la rupture avec l'Antiquité."},
        {"content": "Sacre de Charlemagne comme empereur", "correct": "800", "explication": "Charlemagne est couronné à Rome par le pape Léon III le jour de Noël l'an 800."},
        {"content": "Arrivée de Christophe Colomb en Amérique", "correct": "1492", "explication": "Cette date clé marque le début de la Renaissance."},
        {"content": "Prise de la Bastille", "correct": "1789", "explication": "Le 14 juillet 1789 est l'événement fondateur marquant le début de la Révolution française."}
      ],
      "bareme": "lambda student_answer, soluce_answer: (sum(1 for k, v in soluce_answer.items() if student_answer.get(k) and student_answer[k][0] == v) / len(student_answer)) * 100 if student_answer else 0",
      "feedbacks": {
        "correct": "Toutes les associations chronologiques sont parfaitement exactes.",
        "partial": "Certains événements historiques n'ont pas été déposés sur les bons repères temporels.",
        "incorrect": "Aucune des correspondances chronologiques proposées n'est valide."
      }
    }
  ]
}

import builtins
from typing import Optional, Tuple
 
# Récupération du système de log de la plateforme
platon_log = getattr(builtins, "platon_log", print)
 
def calculateGroupOneGrade(exerciseList: list) -> Tuple[bool, Optional[int]]:
    """
    Vérifie les conditions de validation spécifiques pour le Groupe 1.
    Règles : exercice 1 >= 70, exercice 2 >= 85, exercice 3 >= 100 (selon l'ordre dans le groupe).
    """
    # Cartographie de la note maximale obtenue pour chaque index d'exercice
    maxGrades = {}
    for exercise in exerciseList:
        indexSource = exercise["indexSource"]
        grade = exercise["grade"]
        if grade is not None:
            maxGrades[indexSource] = max(maxGrades.get(indexSource, 0), grade)
 
    # Vérification des seuils pour les trois premiers exercices (index 0, 1 et 2)
    hasEx1 = maxGrades.get(0, 0) >= 70
    hasEx2 = maxGrades.get(1, 0) >= 85
    hasEx3 = maxGrades.get(2, 0) >= 100
 
    if hasEx1 and hasEx2 and hasEx3:
        # Si validé, on retourne la moyenne des scores de ces trois exercices cibles
        finalGrade = int((maxGrades[0] + maxGrades[1] + maxGrades[2]) / 3)
        return True, finalGrade
 
    return False, None
 
 
def customGradeManager(lastGroup: int, groupGradeInformation: dict, logs: dict) -> Tuple[Optional[bool], Optional[int]]:
    """
    Gestionnaire personnalisé des règles de validation d'un groupe.
 
    :param lastGroup: Index numérique du groupe venant d'être évalué.
    :param groupGradeInformation: Métriques standards configurées dans l'interface.
    :param logs: Dictionnaire d'historique de performance (conforme à TOVALID.logs).
 
    :return: (valid, grade)
            - valid: True (validé), False (non validé), ou None (déléguer aux règles natives).
            - grade: Entier entre 0 et 100 si valid=True, sinon None.
    """
    exerciseOrder = logs.get("order", [])
    exerciseInfo = logs.get("info", {})
 
    # ---- GROUPE 1 : Validation par paliers de score sur des exercices précis ----
    if lastGroup == 1:
        platon_log(f"[Grader] Évaluation personnalisée lancée pour le Groupe {lastGroup}")
        playedExercises = list(exerciseInfo.values())
        return calculateGroupOneGrade(playedExercises)
 
    # ---- GROUPE 3 : Moyenne glissante et contrainte d'efficacité sur le dernier exercice ----
    if lastGroup == 3:
        # Il faut au minimum 3 exercices complétés pour prétendre à la validation
        if len(exerciseOrder) < 3:
            platon_log("[Grader] Groupe 3 : Nombre d'exercices insuffisant (< 3)")
            return False, None
 
        # Extraction des performances sur les 3 dernières instances jouées (ordre chronologique)
        lastThreeUuids = exerciseOrder[-3:]
        lastThreeExercises = [exerciseInfo[uuid] for uuid in lastThreeUuids]
 
        # Calcul de la moyenne des scores des 3 derniers exercices
        grades = [exercise["grade"] for exercise in lastThreeExercises if exercise["grade"] is not None]
        if len(grades) < 3:
            return False, None
 
        meanGrade = sum(grades) / 3
 
        # Vérification des contraintes strictes sur le TOUT DERNIER exercice exécuté
        lastExercise = lastThreeExercises[-1]
        perfectLastAttempt = lastExercise["attempts"] == 1 and lastExercise["hints"] == 0
 
        # Validation si la moyenne est >= 80 ET le dernier exercice a été réussi du premier coup sans aide
        if meanGrade >= 80 and perfectLastAttempt:
            platon_log(f"[Grader] Groupe 3 validé avec succès ! Note : {int(meanGrade)}")
            return True, int(meanGrade)
 
        platon_log("[Grader] Groupe 3 non validé : conditions de moyenne ou d'essais non remplies.")
        return False, None
 
    # CRITIQUE : Cas par défaut obligatoire. Renvoie toujours (None, None)
    # pour permettre aux autres groupes de basculer sur le comportement standard de PLaTon.
    return None, None