Update app.py

app.py

@@ -1,301 +1,76 @@
-from flask import Flask, render_template, request, jsonify, redirect, url_for
-import aiohttp
-import asyncio
-from bs4 import BeautifulSoup
-import random
-import string
-import json
-import threading
+from flask import Flask, render_template, request, jsonify, session
+from google import genai
 import os
-import time
 from datetime import datetime
-from concurrent.futures import ThreadPoolExecutor
+import uuid
 
 app = Flask(__name__)
+app.secret_key = os.urandom(24)  # Requis pour utiliser les sessions Flask
 
-# Configuration globale
-config = {
-    'base_url': "https://ivoire-startup-tracker-edithbrou.replit.app",
-    'accounts_file': "accounts_data.json",
-    'is_running': False,
-    'batch_size': 10,  # Nombre de requêtes parallèles
-    'progress': {
-        'total': 0,
-        'current': 0,
-        'success': 0,
-        'failed': 0,
-        'last_username': '',
-        'last_status': '',
-        'start_time': None,
-        'end_time': None
-    }
-}
+# Configuration de l'API Gemini (idéalement à déplacer dans un fichier de configuration)
+# os.environ["GOOGLE_API_KEY"] = "VOTRE_GEMINI_API_KEY"
+client = genai.Client(api_key=os.environ.get("GOOGLE_API_KEY", "GEMINI_API_KEY"))
 
-# Fonction pour générer un nom d'utilisateur aléatoire
-def generate_random_username(min_length=8, max_length=12):
-    """Génère un nom d'utilisateur aléatoire d'une longueur raisonnable"""
-    length = random.randint(min_length, max_length)
-    return ''.join(random.choice(string.ascii_lowercase) for _ in range(length))
-
-# Fonction pour générer une adresse email aléatoire
-def generate_random_email():
-    """Génère une adresse email aléatoire"""
-    username = ''.join(random.choice(string.ascii_lowercase) for _ in range(12))
-    domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com"]
-    return f"{username}@{random.choice(domains)}"
-
-# Fonction pour générer un mot de passe aléatoire
-def generate_random_password(length=10):
-    """Génère un mot de passe aléatoire avec un mélange de caractères"""
-    chars = string.ascii_letters + string.digits + "!@#$%^&*()-_=+"  # Éviter certains caractères spéciaux qui pourraient causer des problèmes
-    return ''.join(random.choice(chars) for _ in range(length))
-
-# Fonction asynchrone pour créer un compte
-async def create_account_async(session, is_startup_rep=False):
-    """Crée un compte sur le site web de manière asynchrone"""
-    register_url = f"{config['base_url']}/register"
-    
-    try:
-        # Première requête pour récupérer le token CSRF
-        async with session.get(register_url, timeout=10) as response:
-            if response.status != 200:
-                return {'success': False, 'error': f"Erreur lors de l'accès à la page: {response.status}"}
-            
-            html = await response.text()
-            
-            # Extraire le token CSRF
-            soup = BeautifulSoup(html, 'html.parser')
-            csrf_token_input = soup.find('input', {'id': 'csrf_token'})
-            
-            if not csrf_token_input:
-                return {'success': False, 'error': "Impossible de trouver le token CSRF"}
-                
-            csrf_token = csrf_token_input.get('value')
-            
-            # Générer des informations de compte aléatoires
-            username = generate_random_username()
-            email = generate_random_email()
-            password = generate_random_password()
-            
-            # Préparer les données du formulaire
-            form_data = {
-                'csrf_token': csrf_token,
-                'username': username,
-                'email': email,
-                'password': password,
-                'confirm_password': password,
-                'submit': 'Register'
-            }
-            
-            # Ajouter l'option startup rep si nécessaire
-            if is_startup_rep:
-                form_data['is_startup_rep'] = 'y'
-            
-            # Envoyer le formulaire
-            headers = {
-                'Referer': register_url,
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-            }
-            
-            async with session.post(register_url, data=form_data, headers=headers, timeout=15) as response:
-                result = {
-                    'success': response.status == 200 or response.status == 302,
-                    'username': username,
-                    'email': email,
-                    'password': password,
-                    'is_startup_rep': is_startup_rep,
-                    'created_at': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                    'status_code': response.status
-                }
-                
-                return result
-    
-    except asyncio.TimeoutError:
-        return {'success': False, 'error': "Timeout lors de la requête"}
-    except Exception as e:
-        return {'success': False, 'error': str(e)}
-
-# Fonction pour traiter un lot de comptes en parallèle
-async def process_batch(batch_indices, startup_ratio, accounts):
-    """Traite un lot de comptes en parallèle"""
-    async with aiohttp.ClientSession() as session:
-        tasks = []
-        for i in batch_indices:
-            if not config['is_running']:
-                break
-                
-            is_startup = random.random() < startup_ratio
-            tasks.append(create_account_async(session, is_startup_rep=is_startup))
-        
-        if not tasks:
-            return []
-            
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-        
-        # Traiter les résultats
-        batch_results = []
-        for idx, result in zip(batch_indices, results):
-            if isinstance(result, Exception):
-                config['progress']['failed'] += 1
-                config['progress']['last_status'] = f"Échec de la création du compte {idx+1}: {str(result)}"
-            elif result.get('success', False):
-                config['progress']['success'] += 1
-                config['progress']['last_username'] = result['username']
-                config['progress']['last_status'] = f"Compte {idx+1} créé avec succès"
-                accounts.append(result)
-                batch_results.append(result)
-            else:
-                config['progress']['failed'] += 1
-                config['progress']['last_status'] = f"Échec de la création du compte {idx+1}: {result.get('error', 'Erreur inconnue')}"
-            
-            config['progress']['current'] = idx + 1
-        
-        return batch_results
-
-# Fonction principale pour créer des comptes de manière asynchrone
-async def create_accounts_async(num_accounts, startup_ratio=0.3):
-    """Crée plusieurs comptes en parallèle de manière asynchrone"""
-    # Charger les comptes existants
-    accounts = []
-    if os.path.exists(config['accounts_file']):
-        try:
-            with open(config['accounts_file'], 'r') as f:
-                accounts = json.load(f)
-        except:
-            accounts = []
-    
-    # Traiter les comptes par lots
-    batch_size = config['batch_size']
-    for start_idx in range(0, num_accounts, batch_size):
-        if not config['is_running']:
-            break
-            
-        end_idx = min(start_idx + batch_size, num_accounts)
-        batch_indices = list(range(start_idx, end_idx))
-        
-        # Traiter un lot de comptes
-        await process_batch(batch_indices, startup_ratio, accounts)
-        
-        # Enregistrer les données après chaque lot
-        with open(config['accounts_file'], 'w') as f:
-            json.dump(accounts, f, indent=2)
-            
-        # Petite pause pour éviter de surcharger le serveur
-        await asyncio.sleep(1)
-    
-    return accounts
-
-# Fonction pour lancer la création de comptes en arrière-plan
-def create_accounts_background(num_accounts, startup_ratio=0.3):
-    config['progress'] = {
-        'total': num_accounts,
-        'current': 0,
-        'success': 0,
-        'failed': 0,
-        'last_username': '',
-        'last_status': 'Démarrage...',
-        'start_time': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        'end_time': None
-    }
+@app.route('/')
+def index():
+    # Créer un ID de session unique s'il n'existe pas déjà
+    if 'session_id' not in session:
+        session['session_id'] = str(uuid.uuid4())
+    return render_template('index.html')
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    data = request.json
+    user_message = data.get('message', '')
     
-    # Créer une boucle asyncio dans un nouveau thread
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
+    # Récupérer ou créer une session de chat pour cet utilisateur
+    session_id = session.get('session_id')
+    chat_session = get_or_create_chat_session(session_id)
     
     try:
-        accounts = loop.run_until_complete(create_accounts_async(num_accounts, startup_ratio))
+        # Envoyer le message à Gemini et obtenir la réponse
+        response = chat_session.send_message(user_message)
         
-        # Mise à jour finale
-        config['progress']['end_time'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        config['progress']['last_status'] = "Terminé"
+        # Formater l'historique pour l'interface
+        history = []
+        for msg in chat_session.get_history():
+            history.append({
+                'role': msg.role,
+                'content': msg.parts[0].text,
+                'timestamp': datetime.now().strftime("%H:%M")
+            })
         
-        # Enregistrement final
-        with open(config['accounts_file'], 'w') as f:
-            json.dump(accounts, f, indent=2)
-            
+        return jsonify({
+            'response': response.text,
+            'history': history
+        })
     except Exception as e:
-        config['progress']['last_status'] = f"Erreur: {str(e)}"
-    finally:
-        config['is_running'] = False
-        loop.close()
-
-# Routes Flask
-@app.route('/')
-def index():
-    return render_template('index.html', config=config)
-
-@app.route('/start', methods=['POST'])
-def start():
-    if config['is_running']:
-        return jsonify({"status": "error", "message": "Une génération est déjà en cours"})
-    
-    num_accounts = int(request.form.get('num_accounts', 10))
-    startup_ratio = float(request.form.get('startup_ratio', 0.3))
-    batch_size = int(request.form.get('batch_size', config['batch_size']))
-    
-    # Mettre à jour la taille du lot
-    config['batch_size'] = min(batch_size, 20)  # Limiter à 20 pour éviter de surcharger le serveur
-    config['is_running'] = True
+        return jsonify({'error': str(e)}), 500
+
+def get_or_create_chat_session(session_id):
+    """
+    Récupère une session de chat existante ou en crée une nouvelle.
+    Dans une application réelle, vous pourriez stocker cela dans une base de données.
+    """
+    # Utilisation d'un dictionnaire global pour stocker les sessions (pour cet exemple)
+    # Dans une application réelle, utilisez Redis ou une base de données
+    if not hasattr(app, 'chat_sessions'):
+        app.chat_sessions = {}
     
-    # Démarrer le processus en arrière-plan
-    thread = threading.Thread(target=create_accounts_background, args=(num_accounts, startup_ratio))
-    thread.daemon = True
-    thread.start()
+    if session_id not in app.chat_sessions:
+        app.chat_sessions[session_id] = client.chats.create(model="gemini-2.0-flash")
     
-    return jsonify({"status": "success", "message": "Génération démarrée"})
-
-@app.route('/stop', methods=['POST'])
-def stop():
-    config['is_running'] = False
-    return jsonify({"status": "success", "message": "Arrêt demandé"})
-
-@app.route('/progress')
-def progress():
-    return jsonify(config['progress'])
-
-@app.route('/accounts')
-def view_accounts():
-    page = int(request.args.get('page', 1))
-    per_page = 20
-    
-    accounts = []
-    if os.path.exists(config['accounts_file']):
-        try:
-            with open(config['accounts_file'], 'r') as f:
-                accounts = json.load(f)
-        except:
-            accounts = []
-            
-    total_accounts = len(accounts)
-    total_pages = (total_accounts + per_page - 1) // per_page
+    return app.chat_sessions[session_id]
+
+@app.route('/reset', methods=['POST'])
+def reset_chat():
+    """Réinitialise la session de chat actuelle"""
+    session_id = session.get('session_id')
+    if hasattr(app, 'chat_sessions') and session_id in app.chat_sessions:
+        # Créer une nouvelle session
+        app.chat_sessions[session_id] = client.chats.create(model="gemini-2.0-flash")
     
-    start_idx = (page - 1) * per_page
-    end_idx = start_idx + per_page
-    
-    current_accounts = accounts[start_idx:end_idx]
-    
-    return render_template(
-        'accounts.html',
-        accounts=current_accounts,
-        page=page,
-        total_pages=total_pages,
-        total_accounts=total_accounts
-    )
-
-@app.route('/script.js')
-def serve_js():
-    return render_template('script.js'), 200, {'Content-Type': 'application/javascript'}
-
-@app.route('/clear', methods=['POST'])
-def clear_accounts():
-    """Supprime tous les comptes enregistrés"""
-    if os.path.exists(config['accounts_file']):
-        try:
-            os.remove(config['accounts_file'])
-            return jsonify({"status": "success", "message": "Données des comptes supprimées"})
-        except Exception as e:
-            return jsonify({"status": "error", "message": f"Erreur lors de la suppression: {str(e)}"})
-    return jsonify({"status": "success", "message": "Aucun fichier à supprimer"})
+    return jsonify({'status': 'success'})
 
 if __name__ == '__main__':
     app.run(debug=True)