Spaces:

Docfile
/

Attaque2

Running

App Files Files Community

Docfile commited on Apr 6

Commit

b7844e1

verified ·

1 Parent(s): e1feafa

Upload app.py

Browse files

Files changed (1) hide show

app.py +150 -443

app.py CHANGED Viewed

@@ -1,464 +1,171 @@
-# -*- coding: utf-8 -*- # Bonne pratique d'ajouter l'encodage
-# Importations nécessaires
-from flask import Flask, request, render_template_string, jsonify, redirect, url_for
-import requests
-import threading
-import uuid  # Pour générer des identifiants uniques pour chaque tâche
-import time
-import copy  # Pour copier le payload pour chaque requête
-from typing import Dict, Any, List, Tuple, Optional # Pour les annotations de type
-# --- Configuration ---
-TARGET_URL: str = "https://hook.us1.make.com/zal5qn0ggbewmvtsbo2uenfno8tz3n56"
-BASE_PAYLOAD: Dict[str, Any] = {
-    "name": "Testeur Auto ",
-    "email": "yoo+auto@example.com",  # Ajout de '+auto' pour distinguer
-    "company": "aragon Inc.",
-    "message": "Ceci est un test automatisé via Flask.",
-    "date": "2023-10-27T10:30:00Z",  # Tu pourrais rendre cette date dynamique si besoin
-    "source": "http://simulateur-bsbs-flask.com"
-}
-# Constantes pour les statuts (évite les fautes de frappe)
-STATUS_STARTING: str = 'starting'
-STATUS_RUNNING: str = 'running'
-STATUS_COMPLETED: str = 'completed'
-STATUS_FAILED: str = 'failed'
-# Optional: STATUS_COMPLETED_WITH_ERRORS: str = 'completed_with_errors'
-# Structure pour stocker l'état des tâches (jobs) en mémoire
-# Format: { 'job_id': {'status': str, 'total': int, 'completed_count': int, 'error_count': int, 'errors': List[Dict[str, Any]] } }
-jobs: Dict[str, Dict[str, Any]] = {}
-jobs_lock = threading.Lock()  # Pour éviter les problèmes d'accès concurrents au dict jobs
-app = Flask(__name__) # Correction de l'initialisation de Flask
-# --- Templates HTML (inchangés, car ils semblent corrects) ---
-# Page d'accueil pour démarrer les requêtes
-HTML_INDEX = """
-<!DOCTYPE html>
-<html lang="fr">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Lanceur de Requêtes</title>
-    <style>
-        body { font-family: sans-serif; margin: 20px; background-color: #f4f4f4; color: #333; }
-        h1, h2 { color: #555; }
-        label { display: block; margin-bottom: 5px; font-weight: bold; }
-        input[type=number] { width: 100px; padding: 8px; margin-bottom: 15px; border: 1px solid #ccc; border-radius: 4px; }
-        button { padding: 10px 15px; cursor: pointer; background-color: #007bff; color: white; border: none; border-radius: 4px; }
-        button:hover { background-color: #0056b3; }
-        .error { color: red; margin-top: 10px; font-weight: bold; }
-        ul { list-style: none; padding: 0; }
-        li { background-color: #fff; margin-bottom: 10px; padding: 10px; border: 1px solid #ddd; border-radius: 4px; }
-        li a { text-decoration: none; color: #007bff; }
-        li a:hover { text-decoration: underline; }
-        .job-info { font-size: 0.9em; color: #666; }
-    </style>
-</head>
-<body>
-    <h1>Envoyer des Requêtes POST en Masse</h1>
-    <form method="POST" action="{{ url_for('start_requests') }}">
-        <label for="num_requests">Nombre de requêtes à envoyer :</label>
-        <input type="number" id="num_requests" name="num_requests" min="1" required value="10">
-        <button type="submit">Lancer les requêtes</button>
-    </form>
-    {% if error %}
-        <p class="error">{{ error }}</p>
-    {% endif %}
-    <h2>Tâches récentes :</h2>
-    <ul>
-        {% for job_id, job_info in jobs_list.items() %}
-            <li>
-                <a href="{{ url_for('job_status', job_id=job_id) }}">Tâche {{ job_id }}</a>
-                <span class="job-info">
-                    (Statut : {{ job_info.status }}, {{ job_info.completed_count }}/{{ job_info.total }} requêtes traitées, {{ job_info.error_count }} erreurs)
-                </span>
-            </li>
-        {% else %}
-            <li>Aucune tâche récente.</li>
-        {% endfor %}
-    </ul>
-</body>
-</html>
-"""
-# Page pour suivre la progression d'une tâche spécifique
-HTML_STATUS = """
-<!DOCTYPE html>
-<html lang="fr">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Statut Tâche {{ job_id }}</title>
-    <style>
-        body { font-family: sans-serif; margin: 20px; background-color: #f4f4f4; color: #333; }
-        h1 { color: #555; }
-        #progress-bar-container { width: 100%; background-color: #e0e0e0; border-radius: 5px; margin-bottom: 10px; overflow: hidden; } /* Overflow hidden for border radius */
-        #progress-bar { width: 0%; height: 30px; background-color: #28a745; /* Green default */ text-align: center; line-height: 30px; color: white; border-radius: 0; /* Radius handled by container */ transition: width 0.5s ease-in-out, background-color 0.5s ease-in-out; }
-        .error-log { margin-top: 15px; max-height: 300px; overflow-y: auto; border: 1px solid #ccc; padding: 10px; background-color: #f9f9f9; border-radius: 4px;}
-        .error-log h3 { margin-top: 0; }
-        .error-log p { margin: 5px 0; font-size: 0.9em; color: #dc3545; } /* Red error text */
-        .status-message { font-weight: bold; margin-bottom: 15px; padding: 10px; background-color: #e9ecef; border-radius: 4px; }
-        a { color: #007bff; text-decoration: none; }
-        a:hover { text-decoration: underline; }
-    </style>
-</head>
-<body>
-    <h1>Statut de la Tâche : {{ job_id }}</h1>
-    <div id="status-message" class="status-message">Chargement des informations...</div>
-    <div id="progress-bar-container">
-        <div id="progress-bar">0%</div>
-    </div>
-    <p>Requêtes traitées : <span id="completed">0</span> / <span id="total">?</span></p>
-    <p>Erreurs rencontrées : <span id="errors">0</span></p>
-    <div id="error-details" class="error-log" style="display: none;">
-        <h3>Détails des erreurs :</h3>
-        <div id="error-list"></div>
-    </div>
-    <p><a href="{{ url_for('index') }}">Retour à l'accueil</a></p>
-    <script>
-        const jobId = "{{ job_id }}";
-        const statusMessageEl = document.getElementById('status-message');
-        const progressBarEl = document.getElementById('progress-bar');
-        const completedEl = document.getElementById('completed');
-        const totalEl = document.getElementById('total');
-        const errorsEl = document.getElementById('errors');
-        const errorDetailsEl = document.getElementById('error-details');
-        const errorListEl = document.getElementById('error-list');
-        let intervalId = null;
-        let lastStatus = ""; // Pour éviter des mises à jour inutiles si le statut n'a pas changé
-        function updateStatus() {
-            fetch(`/api/status/${jobId}`)
-                .then(response => {
-                    if (!response.ok) {
-                        // Si 404, la tâche n'existe pas (ou plus), arrêter les requêtes
-                        if (response.status === 404) {
-                           statusMessageEl.textContent = "Erreur: Tâche non trouvée.";
-                           throw new Error('Job Not Found'); // Pour arrêter l'intervalle dans le catch
-                        }
-                        throw new Error(`Erreur HTTP: ${response.status}`);
-                    }
-                    return response.json();
-                })
-                .then(data => {
-                    if (!data) { // Devrait être géré par le 404 mais double sécurité
-                        statusMessageEl.textContent = "En attente des données...";
-                        return;
-                    }
-                    // Comparer avec le statut précédent pour éviter de redessiner si rien n'a changé
-                    const currentDataSignature = `${data.status}-${data.completed_count}-${data.error_count}`;
-                    if (currentDataSignature === lastStatus) {
-                        // console.log("Pas de changement de statut détecté.");
-                        return; // Rien à faire
-                    }
-                    lastStatus = currentDataSignature;
-                    // Mise à jour des éléments DOM
-                    completedEl.textContent = data.completed_count;
-                    totalEl.textContent = data.total;
-                    errorsEl.textContent = data.error_count;
-                    statusMessageEl.textContent = `Statut : ${data.status}`; // Utilise les constantes définies côté serveur
-                    let percentage = 0;
-                    if (data.total > 0) {
-                        // On calcule le pourcentage sur le nombre total de requêtes à faire
-                        percentage = Math.round((data.completed_count / data.total) * 100);
-                    }
-                    progressBarEl.style.width = percentage + '%';
-                    progressBarEl.textContent = percentage + '%';
-                    // Afficher les erreurs s'il y en a
-                    if (data.error_count > 0 && data.errors && data.errors.length > 0) {
-                        errorListEl.innerHTML = ''; // Vider les erreurs précédentes
-                        data.errors.forEach(err => {
-                            const p = document.createElement('p');
-                            // Utilisation de textContent pour éviter les injections XSS potentielles si les messages d'erreur contenaient du HTML
-                            p.textContent = `Req ${err.index}: ${err.error}`;
-                            errorListEl.appendChild(p);
-                        });
-                        errorDetailsEl.style.display = 'block';
-                    } else {
-                        errorDetailsEl.style.display = 'none';
-                    }
-                    // Gérer la fin de la tâche
-                    if (data.status === '{{ STATUS_COMPLETED }}' || data.status === '{{ STATUS_FAILED }}') {
-                        if (intervalId) {
-                            clearInterval(intervalId);
-                            intervalId = null; // Arrête les mises à jour futures
-                            app.logger.info(f"Mises à jour automatiques arrêtées pour la tâche {jobId} (statut final: {data.status}).");
-                        }
-                        // Mettre à jour la couleur de la barre de progression en fonction du résultat final
-                        if (data.status === '{{ STATUS_COMPLETED }}' && data.error_count == 0) {
-                            progressBarEl.style.backgroundColor = '#28a745'; // Vert succès
-                        } else if (data.status === '{{ STATUS_COMPLETED }}' && data.error_count > 0) {
-                            progressBarEl.style.backgroundColor = '#ffc107'; // Jaune/Orange pour succès avec erreurs
-                        } else { // STATUS_FAILED
-                            progressBarEl.style.backgroundColor = '#dc3545'; // Rouge échec
-                        }
-                    } else {
-                         // Si la tâche est en cours, s'assurer que la couleur est celle par défaut (ou une couleur "en cours")
-                         progressBarEl.style.backgroundColor = '#007bff'; // Bleu pour en cours
-                    }
-                })
-                .catch(error => {
-                    console.error("Erreur lors de la récupération du statut:", error);
-                    if (error.message !== 'Job Not Found') { // Ne pas écraser le message "Tâche non trouvée"
-                       statusMessageEl.textContent = "Erreur lors de la récupération du statut.";
-                    }
-                    // Arrêter les mises à jour en cas d'erreur persistante ou de tâche non trouvée
-                    if (intervalId) {
-                        clearInterval(intervalId);
-                        intervalId = null;
-                        app.logger.error(f"Arrêt des mises à jour pour la tâche {jobId} suite à une erreur: {error}");
-                    }
-                    // Optionnel: Changer la couleur de la barre en cas d'erreur de récupération
-                    progressBarEl.style.backgroundColor = '#6c757d'; // Gris pour état indéterminé/erreur
-                });
-        }
-        // Démarrer la mise à jour : première mise à jour immédiate, puis toutes les 2 secondes
-        updateStatus();
-        if (!intervalId && statusMessageEl.textContent !== "Erreur: Tâche non trouvée.") { // Ne pas démarrer l'intervalle si la tâche n'est déjà pas trouvée
-           intervalId = setInterval(updateStatus, 2000);
-        }
-    </script>
-</body>
-</html>
-"""
-# --- Fonctions Logiques ---
-def send_single_request(target_url: str, payload: Dict[str, Any], job_id: str, request_index: int) -> Tuple[bool, Optional[str]]:
-    """
-    Envoie UNE requête POST unique à la cible.
-    Args:
-        target_url: L'URL à laquelle envoyer la requête.
-        payload: Le dictionnaire de base du payload.
-        job_id: L'ID de la tâche parente (pour logs/debug).
-        request_index: L'index de cette requête dans la tâche (0-based).
-    Returns:
-        Un tuple (succès: bool, message_erreur: Optional[str]).
-    """
-    # Crée une copie profonde pour éviter de modifier l'original entre les threads
-    # et pour ajouter des informations spécifiques à cette requête.
-    current_payload = copy.deepcopy(payload)
-    # Personnalisation du message pour identifier la requête spécifique
-    current_payload['message'] += f" (Requête {request_index + 1} / Job {job_id})"
-    # Ajout d'un UUID unique à chaque requête pour un suivi fin si nécessaire côté serveur cible
-    current_payload['request_uuid'] = str(uuid.uuid4())
-    # Optionnel: Mettre à jour la date/heure au moment de l'envoi
-    # from datetime import datetime, timezone
-    # current_payload['date'] = datetime.now(timezone.utc).isoformat()
     try:
-        response = requests.post(target_url, json=current_payload, timeout=30)  # Timeout de 30 secondes
-        response.raise_for_status()  # Lève une exception pour les codes d'erreur HTTP (4xx, 5xx)
-        # app.logger.debug(f"Job {job_id} - Requête {request_index + 1}: Succès (Status {response.status_code})")
-        return True, None  # Succès
-    except requests.exceptions.Timeout:
-        error_msg = f"Timeout après 30s pour Req {request_index + 1}"
-        app.logger.warning(f"Job {job_id}: {error_msg}")
-        return False, error_msg
-    except requests.exceptions.HTTPError as e:
-        error_msg = f"Erreur HTTP {e.response.status_code} pour Req {request_index + 1}: {e.response.reason}"
-        app.logger.warning(f"Job {job_id}: {error_msg} - Réponse: {e.response.text[:200]}") # Log début de réponse
-        return False, error_msg
-    except requests.exceptions.RequestException as e:
-        # Capture les autres erreurs (DNS, connexion refusée, etc.)
-        error_msg = f"Erreur Réseau/Requête pour Req {request_index + 1}: {str(e)}"
-        app.logger.error(f"Job {job_id}: {error_msg}")
-        return False, error_msg # Échec avec message d'erreur
-def background_task(job_id: str, num_requests: int, target_url: str, base_payload: Dict[str, Any]):
-    """
-    Fonction exécutée dans un thread séparé pour envoyer toutes les requêtes d'une tâche.
-    Met à jour l'état de la tâche dans le dictionnaire partagé `jobs`.
-    """
-    app.logger.info(f"Tâche {job_id}: Démarrage de {num_requests} requêtes vers {target_url}")
-    completed_count: int = 0
-    error_count: int = 0
-    error_messages: List[Dict[str, Any]] = []
-    # Note: L'initialisation de la tâche est maintenant faite dans /start avant le lancement du thread.
-    # La partie ci-dessous est redondante mais laissée commentée pour info.
-    # # Vérifier/Initialiser le statut (au cas où, bien que fait dans /start)
-    # with jobs_lock:
-    #     if job_id not in jobs:
-    #         app.logger.warning(f"Tâche {job_id} non trouvée dans jobs au démarrage du thread. Initialisation.")
-    #         jobs[job_id] = {
-    #             'status': STATUS_RUNNING, # On la met directement en running
-    #             'total': num_requests,
-    #             'completed_count': 0,
-    #             'error_count': 0,
-    #             'errors': []
-    #         }
-    #     else:
-    #         # Si elle existe déjà (normal), s'assurer qu'elle est en running
-    #         jobs[job_id]['status'] = STATUS_RUNNING
-    # Mettre à jour le statut en 'running' une fois démarré
-    with jobs_lock:
-        if job_id in jobs:
-             jobs[job_id]['status'] = STATUS_RUNNING
         else:
-            # Cas très improbable si /start n'a pas fini avant que le thread ne check
-            app.logger.error(f"Tâche {job_id} non trouvée au moment de passer en status RUNNING.")
-            return # Arrêter le thread si la tâche n'existe pas
-    for i in range(num_requests):
-        success, error_msg = send_single_request(target_url, base_payload, job_id, i)
-        # Mettre à jour la progression dans le dictionnaire partagé (section critique)
-        with jobs_lock:
-            # Vérifier si la tâche existe toujours (elle pourrait être supprimée?)
-            if job_id not in jobs:
-                app.logger.warning(f"Tâche {job_id} disparue pendant l'exécution. Arrêt.")
-                break # Sortir de la boucle si la tâche n'est plus suivie
-            # Incrémenter le compteur des requêtes traitées
-            jobs[job_id]['completed_count'] += 1
-            completed_count = jobs[job_id]['completed_count'] # Mettre à jour la variable locale aussi
-            if not success:
-                jobs[job_id]['error_count'] += 1
-                error_count = jobs[job_id]['error_count'] # Mettre à jour la variable locale
-                # Ajouter les détails de l'erreur (index basé sur 1 pour l'affichage)
-                error_detail = {'index': i + 1, 'error': error_msg or "Erreur inconnue"}
-                jobs[job_id]['errors'].append(error_detail)
-                # Gardons seulement les X dernières erreurs pour éviter de saturer la mémoire
-                max_errors_to_keep = 100
-                jobs[job_id]['errors'] = jobs[job_id]['errors'][-max_errors_to_keep:]
-        # Petite pause optionnelle pour ne pas surcharger la cible ou le réseau local
-        # time.sleep(0.05) # 50ms pause
-    # Marquer la tâche comme terminée une fois la boucle finie
-    with jobs_lock:
-        if job_id in jobs:
-            # Déterminer le statut final basé sur les erreurs
-            # Si toutes les requêtes ont échoué -> FAILED
-            # Sinon -> COMPLETED (le nombre d'erreurs indique si c'était parfait ou non)
-            final_status = STATUS_FAILED if error_count == num_requests and num_requests > 0 else STATUS_COMPLETED
-            jobs[job_id]['status'] = final_status
-            app.logger.info(f"Tâche {job_id}: Terminé. Statut final: {final_status}. {completed_count - error_count}/{num_requests} succès, {error_count} erreurs.")
-        else:
-            app.logger.warning(f"Tâche {job_id} non trouvée à la fin de l'exécution pour marquer comme terminée.")
-# --- Routes Flask ---
-@app.route('/', methods=['GET'])
-def index():
-    """Affiche la page d'accueil avec le formulaire et la liste des tâches."""
-    with jobs_lock:
-        # Trie les tâches par clé (ID), en ordre inverse (plus récent d'abord si UUID approxime le temps)
-        # Pour un tri chronologique fiable, il faudrait ajouter un timestamp lors de la création de la tâche.
-        sorted_jobs = dict(sorted(jobs.items(), reverse=True))
-    return render_template_string(HTML_INDEX, jobs_list=sorted_jobs)
-@app.route('/start', methods=['POST'])
-def start_requests():
-    """
-    Reçoit le nombre de requêtes depuis le formulaire,
-    valide l'entrée, crée une nouvelle tâche et lance le thread d'arrière-plan.
-    Redirige vers la page de statut de la nouvelle tâche.
-    """
-    num_requests_str = request.form.get('num_requests')
-    num_requests: int = 0
     try:
-        num_requests = int(num_requests_str)
-        if num_requests <= 0:
-            raise ValueError("Le nombre de requêtes doit être un entier positif.")
-        if num_requests > 10000: # Limite de sécurité (optionnelle)
-             raise ValueError("Le nombre de requêtes est limité à 10000.")
-    except (TypeError, ValueError, AttributeError) as e:
-        app.logger.warning(f"Tentative de démarrage échouée - nombre invalide: '{num_requests_str}' - Erreur: {e}")
-        # Correction: Il faut re-passer la liste des jobs au template d'index en cas d'erreur
-        with jobs_lock:
-            sorted_jobs = dict(sorted(jobs.items(), reverse=True))
-        return render_template_string(HTML_INDEX, error=f"Nombre de requêtes invalide : {e}", jobs_list=sorted_jobs), 400
-    # Générer un ID de tâche unique (partie courte d'un UUID v4)
-    job_id: str = str(uuid.uuid4())[:8]
-    # Initialiser l'état de la tâche dans le dictionnaire partagé (section critique)
-    with jobs_lock:
-        jobs[job_id] = {
-            'status': STATUS_STARTING,  # Statut initial avant que le thread ne démarre vraiment
-            'total': num_requests,
-            'completed_count': 0,
-            'error_count': 0,
-            'errors': []
-            # Optionnel: Ajouter un timestamp de création
-            # 'created_at': datetime.now(timezone.utc).isoformat()
-        }
-    # Créer et démarrer le thread pour exécuter la tâche en arrière-plan
-    thread = threading.Thread(
-        target=background_task,
-        args=(job_id, num_requests, TARGET_URL, BASE_PAYLOAD),
-        daemon=True # Permet au programme principal de quitter même si des threads sont encore en cours d'exécution
-    )
-    thread.start()
-    app.logger.info(f"Nouvelle tâche {job_id} démarrée pour {num_requests} requêtes.")
-    # Rediriger l'utilisateur vers la page de statut de cette nouvelle tâche
-    return redirect(url_for('job_status', job_id=job_id))
-@app.route('/status/<job_id>', methods=['GET'])
-def job_status(job_id: str):
-    """Affiche la page HTML de suivi pour une tâche spécifique (identifiée par job_id)."""
-    with jobs_lock:
-        # Vérifier si la tâche existe juste pour éviter d'afficher une page pour un ID invalide
-        if job_id not in jobs:
-            app.logger.warning(f"Tentative d'accès à la page de statut pour une tâche inexistante: {job_id}")
-            return "Tâche non trouvée", 404
-    # La page HTML contient le JavaScript qui appellera l'API '/api/status/<job_id>'
-    # pour obtenir les données de progression dynamiquement.
-    # On passe les constantes de statut au template pour que le JS puisse les utiliser
-    return render_template_string(HTML_STATUS, job_id=job_id,
-                                  STATUS_COMPLETED=STATUS_COMPLETED,
-                                  STATUS_FAILED=STATUS_FAILED)
-@app.route('/api/status/<job_id>', methods=['GET'])
-def api_job_status(job_id: str):
-    """
-    Fournit l'état actuel d'une tâche spécifique au format JSON.
-    Utilisé par le JavaScript de la page de statut pour les mises à jour.
-    """
-    with jobs_lock:
-        # Obtenir les informations de la tâche. Utiliser .get() pour gérer le cas où l'ID n'existe pas.
-        job_info = jobs.get(job_id)
-    if job_info:
-        # Renvoyer une copie profonde pour éviter toute modification concurrente pendant la sérialisation JSON
-        # Bien que le lock aide, c'est une sécurité supplémentaire, surtout si les structures de données deviennent complexes.
-        return jsonify(copy.deepcopy(job_info))
-    else:
-        # Si la tâche n'est pas trouvée, renvoyer une réponse JSON avec une erreur 404.
-        app.logger.warning(f"API: Statut demandé pour tâche inexistante: {job_id}")
-        return jsonify({"error": "Tâche non trouvée", "job_id": job_id}), 404
-# --- Démarrage de l'application ---
 if __name__ == '__main__':
-    # Utiliser host='0.0.0.0' pour rendre l'application accessible
-    # depuis d'autres machines sur le même réseau local.
-    # ATTENTION : debug=True ne doit JAMAIS être utilisé dans un environnement de production.
-    # Il expose des vulnérabilités de sécurité et affecte les performances.
-    print("Démarrage du serveur Flask...")
-    print(f"Accéder à l'application via http://localhost:5000 ou http://<votre_ip_locale>:5000")
-    app.run(host='0.0.0.0', port=5000, debug=True) # Mettre debug=False pour la production

+import os
+import json
+from textwrap import dedent
+from flask import Flask, render_template, request, jsonify
+from crewai import Agent, Crew, Process, Task
+from crewai_tools import SerperDevTool
+from langchain_google_genai import ChatGoogleGenerativeAI
+from typing import List, Dict, Any
+# Configuration (use .env in production)
+os.environ["GEMINI_API_KEY"] = "AIzaSyCQpoVCdk7h7MvAQKZOUfcnkQYVkHmAKwI"
+os.environ["SERPER_API_KEY"] = "9b90a274d9e704ff5b21c0367f9ae1161779b573"
+gemini_api_key = os.environ.get("GEMINI_API_KEY")
+serper_api_key = os.environ.get("SERPER_API_KEY")
+if not gemini_api_key:
+    raise ValueError("Gemini API key missing.")
+if not serper_api_key:
+    raise ValueError("Serper API key missing.")
+llm = ChatGoogleGenerativeAI(
+    model="gemini-2.0-flash",
+    temperature=0.7,
+    google_api_key=gemini_api_key,
+    max_output_tokens=8000,
+    convert_system_message_to_human=True
+)
+search_tool = SerperDevTool()
+researcher = Agent(
+    role='Chercheur de Sujets Académiques',
+    goal=dedent("""Find factual, precise information on {topic} using the web search tool.
+    Focus on key concepts, definitions, dates, and notable facts."""),
+    backstory=dedent("""A meticulous researcher with a developed critical mind.
+    Synthesizes information from multiple sources to extract the factual essence."""),
+    tools=[search_tool],
+    llm=llm,
+    verbose=True,
+    allow_delegation=False,
+    max_iter=5
+)
+quiz_creator = Agent(
+    role='Concepteur Pédagogique de Quiz',
+    goal=dedent("""Create an engaging multiple-choice quiz based on the factual information
+    provided by the Researcher on {topic}.
+    Formulate clear questions, plausible options, and identify the correct answer.
+    Include a concise explanation for each question."""),
+    backstory=dedent("""A specialist in pedagogical design who excels at transforming
+    raw information into effective evaluation tools."""),
+    llm=llm,
+    verbose=True,
+    allow_delegation=False,
+    max_iter=3
+)
+def extract_json_from_result(result_text: str) -> List[Dict[str, Any]]:
     try:
+        json_start = result_text.find('[')
+        json_end = result_text.rfind(']') + 1
+        if json_start != -1 and json_end != 0 and json_end > json_start:
+            json_str = result_text[json_start:json_end]
+            parsed_json = json.loads(json_str)
+            if isinstance(parsed_json, list):
+                for item in parsed_json:
+                    if not all(k in item for k in ('question', 'options', 'correct_answer')):
+                         raise ValueError("Invalid quiz element structure in JSON.")
+                return parsed_json
+            else:
+                raise ValueError("The extracted JSON is not a list.")
         else:
+            try:
+                parsed_json = json.loads(result_text)
+                if isinstance(parsed_json, list):
+                    for item in parsed_json:
+                        if not all(k in item for k in ('question', 'options', 'correct_answer')):
+                            raise ValueError("Invalid quiz element structure in JSON.")
+                    return parsed_json
+                else:
+                     raise ValueError("The JSON found is not a list.")
+            except json.JSONDecodeError:
+                 raise ValueError("No valid JSON block (list of objects) found in the result.")
+    except json.JSONDecodeError as e:
+        raise ValueError(f"JSON decoding error: {str(e)}. Contenu reçu : '{result_text[:200]}...'")
+    except ValueError as e:
+         raise e
+def research_task(topic: str, agent: Agent) -> Task:
+    return Task(
+        description=dedent(f"""Thorough research on '{topic}'.
+        Identify and compile key factual information: definitions, dates,
+        important figures, fundamental concepts, and significant events.
+        Structure the information clearly and concisely."""),
+        expected_output=dedent(f"""A synthetic report containing the most relevant information
+        on '{topic}', ready to be used to create a quiz.
+        Must include precise and verifiable facts."""),
+        agent=agent,
+    )
+def quiz_creation_task(topic: str, agent: Agent, context_task: Task) -> Task:
+    return Task(
+        description=dedent(f"""Based STRICTLY on the information provided in the context
+        of the research on '{topic}', create a multiple-choice quiz.
+        Generate between 8 and 12 pertinent questions.
+        For each question, provide: 'question', 'options', 'correct_answer', and 'explanation'.
+        The output format MUST be a valid JSON list and NOTHING ELSE."""),
+        expected_output=dedent("""A valid JSON list, where each element is a quiz question
+        with the keys 'question', 'options', 'correct_answer', and 'explanation'."""),
+        agent=agent,
+        context=[context_task]
+    )
+app = Flask(__name__)
+app.secret_key = os.urandom(24)
+@app.route('/')
+def index():
+    return render_template('index.html')
+@app.route('/generate', methods=['POST'])
+def generate_quiz_endpoint():
+    if not request.is_json:
+        return jsonify({'error': 'Invalid request, JSON expected.'}), 400
+    data = request.get_json()
+    topic = data.get('topic')
+    if not topic or not isinstance(topic, str) or len(topic.strip()) == 0:
+        return jsonify({'error': 'The "topic" field is missing or invalid.'}), 400
+    topic = topic.strip()
     try:
+        task_research = research_task(topic=topic, agent=researcher)
+        task_quiz = quiz_creation_task(topic=topic, agent=quiz_creator, context_task=task_research)
+        quiz_crew = Crew(
+            agents=[researcher, quiz_creator],
+            tasks=[task_research, task_quiz],
+            process=Process.sequential,
+            verbose=2
+        )
+        crew_result = quiz_crew.kickoff(inputs={'topic': topic})
+        if not crew_result or not hasattr(quiz_crew, 'tasks_output') or not quiz_crew.tasks_output:
+             return jsonify({'error': 'Quiz generation failed (no crew output).'}), 500
+        last_task_output = quiz_crew.tasks_output[-1]
+        raw_output = last_task_output.raw
+        if not raw_output:
+             return jsonify({'error': 'Quiz generation failed (empty task output).'}), 500
+        try:
+            quiz_data = extract_json_from_result(raw_output)
+            return jsonify({'success': True, 'quiz': quiz_data})
+        except ValueError as json_error:
+            return jsonify({'error': f'Error during quiz finalization: {json_error}'}), 500
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': f'A server error occurred: {str(e)}'}), 500
 if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000, debug=True)