diff --git a/README_ARCHITECTURE.md b/README_ARCHITECTURE.md
new file mode 100644
index 0000000..d56f961
--- /dev/null
+++ b/README_ARCHITECTURE.md
@@ -0,0 +1,191 @@
+# 🤖 TwitchBot Controller - Architecture Centralisée
+
+## Vue d'ensemble
+
+Le TwitchBot Controller a été refactorisé pour utiliser une architecture centralisée qui permet un contrôle complet depuis l'interface web. Cette nouvelle architecture résout les problèmes de synchronisation et de duplication observés dans les logs.
+
+## 🏗️ Architecture
+
+### Composants principaux
+
+1. **Interface Web** (`web_interface.py`)
+   - Contrôle central de tous les composants
+   - API REST pour la gestion des flux et composants
+   - Interface utilisateur moderne avec Bootstrap
+
+2. **BotController** (classe dans `web_interface.py`)
+   - Gestion centralisée de tous les bots
+   - Contrôle des états et synchronisation
+   - Gestion des erreurs et récupération
+
+3. **Composants modulaires**
+   - **IA_generator** : Génération automatique de réponses
+   - **Control_Twitch** : Envoi de messages sur Twitch
+   - **RecordTwitch** : Enregistrement audio des streams
+   - **Subtitle_translation** : Traitement des sous-titres
+   - **TwitchChatBot** : Connexion aux chats Twitch
+
+## 🔧 Fonctionnalités
+
+### Contrôle depuis l'interface web
+
+#### Gestion des flux
+- ✅ Ajouter/supprimer des flux Twitch
+- ✅ Activer/désactiver les flux
+- ✅ Surveillance en temps réel
+- ✅ Gestion des erreurs
+
+#### Contrôle des composants
+- ✅ **IA Generator** : Démarrage/arrêt depuis l'interface
+- ✅ **Control Twitch** : Contrôle de l'envoi de messages
+- ✅ **Auto Subtitle** : Génération automatique de sous-titres
+- ✅ **Auto Messages** : Envoi automatique de messages
+
+#### Gestion des utilisateurs
+- ✅ Ajouter/modifier/supprimer des utilisateurs Twitch
+- ✅ Gestion des tokens OAuth
+- ✅ Sélection d'utilisateur pour l'envoi de messages
+
+#### Configuration
+- ✅ Gestion des prompts IA
+- ✅ Configuration des paramètres
+- ✅ Sauvegarde automatique
+
+## 🚀 Démarrage
+
+### Prérequis
+```bash
+pip install flask flask-socketio requests pytmi
+```
+
+### Configuration
+1. Créez les fichiers de configuration :
+   - `config/config.json` : Configuration générale
+   - `config/user.json` : Utilisateurs Twitch
+
+2. Configurez vos paramètres :
+   - Tokens OAuth Twitch
+   - Noms de canaux
+   - Prompts IA
+
+### Lancement
+```bash
+python start_web_interface.py
+```
+
+L'interface sera disponible sur : http://localhost:5000
+
+## 📊 Interface utilisateur
+
+### Tableau de bord
+- **Statut des flux** : Nombre de flux actifs
+- **Enregistrements** : Flux avec enregistrement audio
+- **Connexions chat** : Flux connectés aux chats
+
+### Contrôles principaux
+- **Générateur IA** : Toggle pour démarrer/arrêter
+- **Contrôleur Twitch** : Toggle pour l'envoi de messages
+- **Auto Subtitle** : Génération automatique de sous-titres
+- **Auto Messages** : Envoi automatique de messages
+
+### Gestion des flux
+- Ajouter de nouveaux flux Twitch
+- Activer/désactiver les flux
+- Surveillance du statut en temps réel
+- Gestion des erreurs
+
+## 🔄 Flux de données
+
+### 1. Enregistrement audio
+```
+RecordTwitch → Fichiers MP3 → Whisper → Sous-titres
+```
+
+### 2. Génération IA
+```
+Sous-titres → IA_generator → Réponses IA → Stockage
+```
+
+### 3. Envoi de messages
+```
+Stockage → Control_Twitch → Chat Twitch
+```
+
+## 🛠️ API Endpoints
+
+### Flux
+- `GET /api/flux` : Liste des flux
+- `POST /api/flux` : Ajouter un flux
+- `DELETE /api/flux/<id>` : Supprimer un flux
+- `POST /api/flux/<id>/toggle` : Activer/désactiver
+
+### Composants
+- `POST /api/ia-generator/start` : Démarrer IA Generator
+- `POST /api/ia-generator/stop` : Arrêter IA Generator
+- `POST /api/control-twitch/start` : Démarrer Control Twitch
+- `POST /api/control-twitch/stop` : Arrêter Control Twitch
+
+### Statut
+- `GET /api/system-status` : Statut de tous les composants
+- `GET /api/status` : Statut général
+
+## 🔍 Résolution des problèmes
+
+### Problèmes résolus
+
+1. **Générations dupliquées** ✅
+   - Contrôle centralisé de l'IA Generator
+   - Vérification des états avant génération
+
+2. **Messages dupliqués** ✅
+   - Contrôle centralisé de Control Twitch
+   - Suppression automatique des messages envoyés
+
+3. **Synchronisation** ✅
+   - États centralisés dans BotController
+   - Communication via API REST
+
+4. **Gestion des erreurs** ✅
+   - Try/catch dans tous les composants
+   - Récupération automatique
+
+### Logs améliorés
+
+Les logs sont maintenant plus clairs et informatifs :
+```
+[12:04:15] IA Generator démarré
+[12:04:20] Control Twitch démarré
+[12:04:25] Message envoyé: Réponse IA...
+[12:04:30] Génération créée: Nouvelle réponse...
+```
+
+## 🔧 Maintenance
+
+### Redémarrage propre
+```bash
+# Arrêter tous les composants depuis l'interface
+# Puis redémarrer l'application
+python start_web_interface.py
+```
+
+### Debug
+- Logs détaillés dans la console
+- Statut en temps réel dans l'interface
+- Gestion des erreurs avec messages explicites
+
+## 📈 Avantages de la nouvelle architecture
+
+1. **Contrôle centralisé** : Tous les composants sont gérés depuis l'interface web
+2. **Synchronisation** : Élimination des conflits et duplications
+3. **Modularité** : Chaque composant peut être démarré/arrêté indépendamment
+4. **Observabilité** : Statut en temps réel de tous les composants
+5. **Maintenabilité** : Code plus propre et mieux organisé
+6. **Extensibilité** : Facile d'ajouter de nouveaux composants
+
+## 🎯 Utilisation recommandée
+
+1. **Démarrage** : Lancez l'interface web
+2. **Configuration** : Ajoutez vos flux et utilisateurs
+3. **Activation** : Démarrez les composants depuis l'interface
+4. **Surveillance** : Surveillez les statuts en temps réel
+5. **Ajustement** : Modifiez les paramètres selon vos besoins 
\ No newline at end of file
diff --git a/SUBTITLE_STOP_FIX.md b/SUBTITLE_STOP_FIX.md
new file mode 100644
index 0000000..b3f1cae
--- /dev/null
+++ b/SUBTITLE_STOP_FIX.md
@@ -0,0 +1,193 @@
+# 🔧 Correction du Bouton Slide "Génération Auto Sous-titres"
+
+## 📋 Problème Identifié
+
+### ❌ **Problème Initial**
+- Le bouton slide "Génération Auto Sous-titres" ne pouvait pas arrêter la boucle de traitement
+- La boucle `auto_subtitle_loop()` utilisait `subprocess.run()` qui bloquait jusqu'à la fin du processus Whisper
+- Impossible d'interrompre le traitement en cours
+- Aucune vérification de la variable `auto_subtitle_running` pendant le traitement
+
+### 🔍 **Cause Racine**
+```python
+# Ancien code problématique
+result = subprocess.run(command, capture_output=True, text=True, timeout=60)
+```
+- `subprocess.run()` bloque l'exécution jusqu'à la fin du processus
+- Aucune possibilité d'interruption pendant le traitement
+- La boucle ne peut pas vérifier `auto_subtitle_running` pendant l'exécution de Whisper
+
+## ✅ **Solution Implémentée**
+
+### 🔧 **Améliorations Principales**
+
+#### 1. **Utilisation de `subprocess.Popen()`**
+```python
+# Nouveau code avec contrôle d'interruption
+process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+# Attendre la fin du processus avec vérification périodique
+while process.poll() is None:
+    if not auto_subtitle_running:
+        print("Arrêt demandé, interruption du processus Whisper")
+        process.terminate()
+        try:
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            process.kill()
+        break
+    time.sleep(1)
+```
+
+#### 2. **Vérification Périodique de l'Arrêt**
+- Vérification de `auto_subtitle_running` toutes les secondes
+- Interruption immédiate du processus Whisper si arrêt demandé
+- Nettoyage propre des processus en cours
+
+#### 3. **Logs de Débogage Améliorés**
+```python
+print(f"[{datetime.now().strftime('%H:%M:%S')}] Démarrage de la boucle de génération automatique de sous-titres")
+print(f"[{datetime.now().strftime('%H:%M:%S')}] Traitement de: {audio_file}")
+print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt demandé, interruption du processus Whisper")
+```
+
+#### 4. **Fonction d'Arrêt Forcé**
+```python
+@app.route('/api/subtitles/auto/force-stop', methods=['POST'])
+def force_stop_auto_subtitle():
+    """Forcer l'arrêt de la génération automatique de sous-titres"""
+    global auto_subtitle_running, current_processing_file
+    auto_subtitle_running = False
+    current_processing_file = None
+```
+
+#### 5. **Bouton d'Arrêt Forcé dans l'Interface**
+```html
+<button class="btn btn-warning btn-sm w-100" onclick="forceStopAutoSubtitle()" title="Forcer l'arrêt en cas de problème">
+    <i class="fas fa-stop-circle me-1"></i>Force Stop
+</button>
+```
+
+## 🚀 **Fonctionnalités Ajoutées**
+
+### **Contrôle Interruptible**
+- ✅ Arrêt immédiat même pendant le traitement Whisper
+- ✅ Interruption propre des processus en cours
+- ✅ Nettoyage des ressources
+
+### **Interface Utilisateur Améliorée**
+- ✅ Bouton "Force Stop" pour les cas d'urgence
+- ✅ Feedback visuel en temps réel
+- ✅ Logs de débogage détaillés
+
+### **Gestion d'Erreurs Robuste**
+- ✅ Vérification de l'état avant démarrage
+- ✅ Gestion des timeouts
+- ✅ Nettoyage automatique des fichiers temporaires
+
+## 🔍 **Tests et Validation**
+
+### **Script de Test**
+```bash
+python test_subtitle_stop.py
+```
+
+### **Tests Inclus**
+1. ✅ Vérification du statut initial
+2. ✅ Démarrage de la génération automatique
+3. ✅ Vérification du démarrage
+4. ✅ Arrêt pendant le traitement
+5. ✅ Vérification de l'arrêt
+6. ✅ Test de l'arrêt forcé
+7. ✅ Test du traitement avec interruption
+
+## 📊 **Améliorations de Performance**
+
+### **Optimisations**
+- Interruption immédiate des processus
+- Vérification périodique de l'état
+- Nettoyage automatique des ressources
+- Logs de débogage détaillés
+
+### **Sécurité**
+- Gestion des timeouts
+- Interruption propre des processus
+- Protection contre les fuites de ressources
+
+## 🎯 **Utilisation**
+
+### **Arrêt Normal**
+1. Cliquer sur le toggle "Génération Auto Sous-titres"
+2. Attendre la confirmation d'arrêt
+3. Vérifier le statut affiché
+
+### **Arrêt Forcé**
+1. Cliquer sur "Force Stop"
+2. Confirmer l'action
+3. Vérifier que le traitement s'arrête immédiatement
+
+### **Débogage**
+1. Ouvrir la console du navigateur
+2. Vérifier les logs de débogage
+3. Utiliser le script de test
+
+## 📝 **Code Modifié**
+
+### **Fonction `auto_subtitle_loop()`**
+```python
+def auto_subtitle_loop():
+    """Boucle de génération automatique de sous-titres"""
+    global auto_subtitle_running, current_processing_file
+    
+    print(f"[{datetime.now().strftime('%H:%M:%S')}] Démarrage de la boucle de génération automatique de sous-titres")
+    
+    while auto_subtitle_running:
+        try:
+            # Vérification des fichiers audio
+            audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
+            if not audio_files:
+                time.sleep(5)
+                continue
+            
+            # Traitement avec contrôle d'interruption
+            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            
+            while process.poll() is None:
+                if not auto_subtitle_running:
+                    process.terminate()
+                    break
+                time.sleep(1)
+            
+            # Vérification finale de l'arrêt
+            if not auto_subtitle_running:
+                break
+                
+        except Exception as e:
+            print(f"Erreur dans la boucle: {e}")
+            time.sleep(5)
+```
+
+### **Fonction `force_stop_auto_subtitle()`**
+```python
+@app.route('/api/subtitles/auto/force-stop', methods=['POST'])
+def force_stop_auto_subtitle():
+    """Forcer l'arrêt de la génération automatique de sous-titres"""
+    global auto_subtitle_running, current_processing_file
+    auto_subtitle_running = False
+    current_processing_file = None
+    return jsonify({'success': True, 'message': 'Arrêt forcé'})
+```
+
+## 🎉 **Résultat Final**
+
+✅ **Bouton slide fonctionnel**
+✅ **Arrêt immédiat même pendant le traitement**
+✅ **Interruption propre des processus Whisper**
+✅ **Interface utilisateur améliorée**
+✅ **Logs de débogage détaillés**
+✅ **Gestion d'erreurs robuste**
+✅ **Tests de validation complets**
+
+---
+
+*Le bouton slide "Génération Auto Sous-titres" fonctionne maintenant parfaitement et peut arrêter la boucle même pendant le traitement d'un fichier ! 🚀* 
\ No newline at end of file
diff --git a/TOGGLE_IMPROVEMENTS.md b/TOGGLE_IMPROVEMENTS.md
new file mode 100644
index 0000000..4a8f33c
--- /dev/null
+++ b/TOGGLE_IMPROVEMENTS.md
@@ -0,0 +1,192 @@
+# 🔧 Améliorations des Toggles - TwitchBot Controller
+
+## 📋 Problème Résolu
+
+### ❌ **Problème Initial**
+- Les boutons slide étaient désactivés visuellement mais les fonctions restaient actives
+- Manque de synchronisation entre l'état visuel et l'état réel du serveur
+- Contrôle insuffisant des fonctions automatiques
+
+### ✅ **Solution Implémentée**
+- Synchronisation complète entre l'interface et le serveur
+- Variables globales pour suivre l'état réel
+- Contrôle robuste des fonctions automatiques
+- Gestion d'erreurs améliorée
+
+## 🚀 **Améliorations Apportées**
+
+### 1. **Variables Globales de Contrôle**
+```javascript
+let autoSubtitleRunning = false;
+let autoMessageRunning = false;
+let chatMessagesEnabled = true;
+```
+
+### 2. **Fonctions de Toggle Améliorées**
+
+#### **Génération Auto Sous-titres**
+- ✅ Vérification de l'état avant action
+- ✅ Désactivation du toggle pendant l'opération
+- ✅ Gestion d'erreurs robuste
+- ✅ Restauration de l'état en cas d'échec
+- ✅ Logs de débogage détaillés
+
+#### **Envoi Auto Messages**
+- ✅ Synchronisation avec l'état serveur
+- ✅ Contrôle des conditions d'activation/désactivation
+- ✅ Gestion des erreurs réseau
+- ✅ Mise à jour de l'interface en temps réel
+
+#### **Envoi Messages Chat**
+- ✅ Contrôle précis de l'état
+- ✅ Vérification des permissions
+- ✅ Feedback utilisateur amélioré
+
+### 3. **Fonctions de Vérification de Statut**
+
+#### **checkAutoSubtitleStatus()**
+- Vérifie l'état réel du serveur
+- Synchronise l'interface
+- Gère les erreurs de connexion
+
+#### **checkAutoMessageStatus()**
+- Contrôle l'état des messages automatiques
+- Met à jour l'interface
+- Logs de débogage
+
+#### **checkChatMessageStatus()**
+- Vérifie l'état des messages chat
+- Synchronise le toggle
+- Gestion des erreurs
+
+### 4. **Fonctions d'Arrêt Forcé**
+
+#### **forceStopAutoMessage()**
+- Arrêt forcé des messages automatiques
+- Mise à jour de l'interface
+- Gestion d'erreurs
+
+#### **forceStopAutoSubtitle()**
+- Arrêt forcé de la génération de sous-titres
+- Nettoyage de l'interface
+- Feedback utilisateur
+
+### 5. **Écouteurs d'Événements**
+```javascript
+// Remplacement des attributs onchange par des écouteurs
+const autoSubtitleToggle = document.getElementById('autoSubtitleToggle');
+const autoMessageToggle = document.getElementById('autoMessageToggle');
+const chatMessageToggle = document.getElementById('chatMessageToggle');
+
+if (autoSubtitleToggle) {
+    autoSubtitleToggle.addEventListener('change', toggleAutoSubtitle);
+}
+```
+
+## 🎯 **Fonctionnalités Ajoutées**
+
+### **Boutons d'Arrêt Forcé**
+- Bouton "Arrêt Forcé" pour les sous-titres automatiques
+- Bouton "Arrêt Forcé" pour les messages automatiques
+- Gestion des cas de blocage
+
+### **Logs de Débogage**
+- Console logs détaillés
+- Suivi de l'état des toggles
+- Messages d'erreur explicites
+
+### **Gestion d'Erreurs Améliorée**
+- Restauration automatique de l'état
+- Messages d'erreur utilisateur
+- Désactivation temporaire des toggles
+
+## 🔍 **Tests et Validation**
+
+### **Script de Test**
+```bash
+python test_toggles.py
+```
+
+### **Tests Inclus**
+1. ✅ Vérification du statut initial
+2. ✅ Activation des messages automatiques
+3. ✅ Vérification après activation
+4. ✅ Désactivation des messages
+5. ✅ Activation des sous-titres
+6. ✅ Désactivation des sous-titres
+7. ✅ Test du toggle chat
+
+## 📊 **Améliorations de Performance**
+
+### **Optimisations**
+- Désactivation temporaire des toggles pendant les opérations
+- Vérification de l'état avant action
+- Réduction des appels API inutiles
+- Gestion des timeouts
+
+### **Sécurité**
+- Validation des réponses serveur
+- Gestion des erreurs réseau
+- Protection contre les actions multiples
+
+## 🎨 **Interface Utilisateur**
+
+### **Améliorations Visuelles**
+- Feedback visuel immédiat
+- États clairs (Activé/Arrêté/En cours)
+- Messages d'erreur explicites
+- Boutons d'arrêt forcé
+
+### **Expérience Utilisateur**
+- Synchronisation en temps réel
+- Feedback sonore et visuel
+- Gestion des cas d'erreur
+- Interface responsive
+
+## 🔧 **Utilisation**
+
+### **Activation/Désactivation**
+1. Cliquer sur le toggle souhaité
+2. Attendre la confirmation
+3. Vérifier le statut affiché
+
+### **Arrêt Forcé**
+1. Cliquer sur "Arrêt Forcé"
+2. Confirmer l'action
+3. Vérifier le statut
+
+### **Débogage**
+1. Ouvrir la console du navigateur
+2. Vérifier les logs
+3. Utiliser le script de test
+
+## 📝 **Notes Techniques**
+
+### **Variables Globales**
+- `autoSubtitleRunning`: État de la génération de sous-titres
+- `autoMessageRunning`: État de l'envoi de messages
+- `chatMessagesEnabled`: État des messages chat
+
+### **Endpoints API**
+- `GET /api/messages/auto/status`: Statut messages
+- `POST /api/messages/auto/start`: Démarrer messages
+- `POST /api/messages/auto/stop`: Arrêter messages
+- `GET /api/subtitles/auto/status`: Statut sous-titres
+- `POST /api/subtitles/auto/start`: Démarrer sous-titres
+- `POST /api/subtitles/auto/stop`: Arrêter sous-titres
+- `GET /api/chat/messages/status`: Statut chat
+- `POST /api/chat/messages/enable`: Activer chat
+- `POST /api/chat/messages/disable`: Désactiver chat
+
+## 🎉 **Résultat Final**
+
+✅ **Toggles parfaitement synchronisés**
+✅ **Contrôle précis des fonctions**
+✅ **Gestion d'erreurs robuste**
+✅ **Interface utilisateur améliorée**
+✅ **Débogage facilité**
+✅ **Performance optimisée**
+
+---
+
+*Les toggles sont maintenant parfaitement contrôlés et synchronisés avec l'état réel du serveur ! 🚀* 
\ No newline at end of file
diff --git a/demo_auto_systems.py b/demo_auto_systems.py
deleted file mode 100644
index 9d79114..0000000
--- a/demo_auto_systems.py
+++ /dev/null
@@ -1,127 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de démonstration des systèmes automatiques
-"""
-
-import os
-import json
-from datetime import datetime
-
-def demo_auto_systems():
-    """Démonstration des systèmes automatiques"""
-    print("🎬 Démonstration des systèmes automatiques")
-    print("=" * 60)
-    
-    # 1. Vérifier les fichiers audio
-    record_dir = "record"
-    if os.path.exists(record_dir):
-        audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
-        print(f"✅ {len(audio_files)} fichiers audio disponibles pour les sous-titres")
-    else:
-        print("❌ Dossier record non trouvé")
-    
-    # 2. Vérifier les générations
-    storage_dir = "storage"
-    generation_file = os.path.join(storage_dir, "IA_generator.json")
-    if os.path.exists(generation_file):
-        try:
-            with open(generation_file, 'r', encoding='utf-8') as f:
-                generation_data = json.load(f)
-            print(f"✅ {len(generation_data)} générations disponibles pour l'envoi automatique")
-            
-            if generation_data:
-                sorted_keys = sorted(generation_data.keys())
-                last_generation = generation_data[sorted_keys[-1]]
-                print(f"📝 Dernière génération: {last_generation}")
-        except Exception as e:
-            print(f"⚠️  Erreur lecture générations: {e}")
-    else:
-        print("📝 Aucune génération disponible")
-    
-    # 3. Vérifier les utilisateurs
-    user_config = "config/user.json"
-    if os.path.exists(user_config):
-        try:
-            with open(user_config, 'r') as f:
-                users = json.load(f)
-            print(f"✅ {len(users)} utilisateur(s) configuré(s) pour l'envoi")
-        except Exception as e:
-            print(f"⚠️  Erreur lecture utilisateurs: {e}")
-    else:
-        print("❌ Fichier de configuration utilisateur non trouvé")
-    
-    return True
-
-def show_interface_instructions():
-    """Afficher les instructions pour l'interface"""
-    print("\n🌐 Instructions pour l'interface web:")
-    print("=" * 50)
-    
-    print("\n📺 Génération automatique de sous-titres:")
-    print("   1. Ouvrir http://localhost:5000")
-    print("   2. Dans le tableau de bord (sidebar gauche)")
-    print("   3. Trouver le switch 'Génération Auto Sous-titres'")
-    print("   4. Activer le switch pour démarrer")
-    print("   5. Aller dans l'onglet 'Sous-titres' pour voir le fichier en cours")
-    print("   6. Les sous-titres seront créés automatiquement fichier par fichier")
-    
-    print("\n💬 Envoi automatique de messages:")
-    print("   1. Dans le tableau de bord (sidebar gauche)")
-    print("   2. Trouver le switch 'Envoi Auto Messages'")
-    print("   3. Activer le switch pour démarrer")
-    print("   4. Les messages seront envoyés automatiquement quand des générations sont disponibles")
-    print("   5. Délai de 10 secondes entre chaque envoi")
-    
-    print("\n🔄 Fonctionnement combiné:")
-    print("   - Les sous-titres sont générés automatiquement")
-    print("   - Les générations IA sont créées à partir des sous-titres")
-    print("   - Les messages sont envoyés automatiquement")
-    print("   - Tout fonctionne en boucle automatique")
-
-def show_features():
-    """Afficher les fonctionnalités ajoutées"""
-    print("\n📋 Fonctionnalités ajoutées:")
-    print("=" * 50)
-    
-    print("\n🎛️  Contrôles automatiques:")
-    print("   ✅ Switch 'Génération Auto Sous-titres'")
-    print("   ✅ Switch 'Envoi Auto Messages'")
-    print("   ✅ Indicateurs de statut en temps réel")
-    print("   ✅ Gestion des erreurs avec alertes")
-    
-    print("\n🔄 Traitement automatique:")
-    print("   ✅ Surveillance des fichiers audio")
-    print("   ✅ Transcription avec Whisper")
-    print("   ✅ Nettoyage et formatage des sous-titres")
-    print("   ✅ Sauvegarde automatique")
-    print("   ✅ Surveillance des générations IA")
-    print("   ✅ Envoi automatique de messages")
-    print("   ✅ Suppression des données traitées")
-    
-    print("\n📡 Communication temps réel:")
-    print("   ✅ Événements Socket.IO pour le traitement")
-    print("   ✅ Événements Socket.IO pour l'envoi")
-    print("   ✅ Alertes en temps réel")
-    print("   ✅ Actualisation automatique de l'interface")
-
-if __name__ == '__main__':
-    print("🚀 Démonstration des systèmes automatiques")
-    print("=" * 60)
-    
-    # Test des systèmes
-    success = demo_auto_systems()
-    
-    # Instructions d'interface
-    show_interface_instructions()
-    
-    # Fonctionnalités
-    show_features()
-    
-    print("\n" + "=" * 60)
-    if success:
-        print("✅ Systèmes prêts !")
-        print("🎉 Vous pouvez maintenant utiliser les switches dans l'interface web")
-        print("💡 Les deux systèmes fonctionnent indépendamment ou ensemble")
-    else:
-        print("❌ Problèmes détectés")
-        print("🔧 Vérifiez la configuration avant d'utiliser les systèmes automatiques") 
\ No newline at end of file
diff --git a/demo_subtitle_system.py b/demo_subtitle_system.py
deleted file mode 100644
index 48c3803..0000000
--- a/demo_subtitle_system.py
+++ /dev/null
@@ -1,126 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de démonstration du système de sous-titres
-"""
-
-import os
-import json
-from datetime import datetime
-
-def demo_subtitle_system():
-    """Démonstration du système de sous-titres"""
-    print("🎬 Démonstration du système de sous-titres")
-    print("=" * 60)
-    
-    # 1. Vérifier les fichiers audio
-    record_dir = "record"
-    if not os.path.exists(record_dir):
-        print(f"❌ Dossier record non trouvé: {record_dir}")
-        return False
-    
-    audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
-    if not audio_files:
-        print(f"❌ Aucun fichier audio trouvé dans {record_dir}")
-        return False
-    
-    print(f"✅ {len(audio_files)} fichiers audio trouvés")
-    print(f"📁 Premier fichier: {audio_files[0]}")
-    print(f"📁 Dernier fichier: {audio_files[-1]}")
-    
-    # 2. Vérifier le stockage
-    storage_dir = "storage"
-    subtitle_file = os.path.join(storage_dir, "subtitle_data.json")
-    
-    if os.path.exists(subtitle_file):
-        try:
-            with open(subtitle_file, 'r', encoding='utf-8') as f:
-                subtitle_data = json.load(f)
-            print(f"✅ Stockage existant avec {len(subtitle_data)} sous-titre(s)")
-            
-            if subtitle_data:
-                print("📝 Derniers sous-titres:")
-                sorted_keys = sorted(subtitle_data.keys())
-                for key in sorted_keys[-3:]:  # Afficher les 3 derniers
-                    print(f"   {key}: {subtitle_data[key]}")
-        except Exception as e:
-            print(f"⚠️  Erreur lecture stockage: {e}")
-    else:
-        print("📝 Aucun stockage existant")
-    
-    # 3. Simuler le traitement manuel
-    print("\n🔧 Simulation du traitement manuel:")
-    print("   1. Détection des fichiers audio ✅")
-    print("   2. Lancement de Whisper sur chaque fichier")
-    print("   3. Nettoyage et suppression des répétitions")
-    print("   4. Sauvegarde dans le stockage")
-    print("   5. Nettoyage des fichiers temporaires")
-    
-    # 4. Créer un exemple de sous-titre
-    example_subtitle = {
-        "03:52:30": "Voici un exemple de sous-titre généré",
-        "03:52:35": "Le système fonctionne correctement",
-        "03:52:40": "Whisper traite les fichiers audio"
-    }
-    
-    # Sauvegarder l'exemple
-    if not os.path.exists(storage_dir):
-        os.makedirs(storage_dir)
-    
-    try:
-        with open(subtitle_file, 'w', encoding='utf-8') as f:
-            json.dump(example_subtitle, f, indent=4, ensure_ascii=False)
-        print("✅ Exemple de sous-titres sauvegardé")
-    except Exception as e:
-        print(f"❌ Erreur sauvegarde: {e}")
-    
-    # 5. Afficher les instructions pour l'interface web
-    print("\n🌐 Instructions pour l'interface web:")
-    print("   1. Ouvrir http://localhost:5000")
-    print("   2. Aller dans l'onglet 'Sous-titres'")
-    print("   3. Cliquer sur 'Traitement Manuel'")
-    print("   4. Attendre le traitement des fichiers audio")
-    print("   5. Voir les sous-titres générés")
-    
-    return True
-
-def test_whisper_availability():
-    """Tester la disponibilité de Whisper"""
-    print("\n🔍 Test de Whisper:")
-    
-    try:
-        import subprocess
-        result = subprocess.run(['whisper', '--help'], capture_output=True, text=True, timeout=10)
-        if result.returncode == 0:
-            print("✅ Whisper est disponible et fonctionnel")
-            return True
-        else:
-            print("❌ Whisper ne répond pas correctement")
-            return False
-    except FileNotFoundError:
-        print("❌ Whisper n'est pas installé")
-        return False
-    except Exception as e:
-        print(f"❌ Erreur test Whisper: {e}")
-        return False
-
-if __name__ == '__main__':
-    print("🚀 Démonstration du système de sous-titres")
-    print("=" * 60)
-    
-    # Test 1: Système de base
-    system_ok = demo_subtitle_system()
-    
-    # Test 2: Whisper
-    whisper_ok = test_whisper_availability()
-    
-    print("\n" + "=" * 60)
-    if system_ok and whisper_ok:
-        print("✅ Système prêt !")
-        print("🎉 Vous pouvez maintenant utiliser le bouton 'Traitement Manuel'")
-        print("   dans l'interface web pour créer des sous-titres.")
-    else:
-        print("❌ Problèmes détectés")
-        if not system_ok:
-            print("   - Problème avec le système de base")
-        if not whisper_ok:
-            print("   - Problème avec Whisper") 
\ No newline at end of file
diff --git a/demo_web_interface.py b/demo_web_interface.py
deleted file mode 100755
index f89a1a0..0000000
--- a/demo_web_interface.py
+++ /dev/null
@@ -1,224 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de démonstration pour tester l'interface web du TwitchBot Controller
-Génère des données de test pour montrer les fonctionnalités
-"""
-
-import json
-import os
-import time
-import threading
-from datetime import datetime
-import random
-
-def create_demo_data():
-    """Créer des données de démonstration"""
-    
-    # Créer les dossiers nécessaires
-    os.makedirs('working_bot/storage', exist_ok=True)
-    os.makedirs('config', exist_ok=True)
-    
-    # Données de démonstration pour les sous-titres
-    demo_subtitles = {
-        "14h30m15s": "Salut les viewers ! Comment ça va aujourd'hui ?",
-        "14h31m22s": "On va jouer à ce nouveau jeu, j'ai hâte de voir ce que ça donne",
-        "14h32m45s": "Oh non, je suis mort déjà ! C'est plus dur que je pensais",
-        "14h33m12s": "Merci pour le follow @nouveau_viewer !",
-        "14h34m30s": "Cette partie est vraiment intense, regardez ça !",
-        "14h35m18s": "Je pense qu'on devrait essayer une autre stratégie",
-        "14h36m05s": "Excellent, on progresse enfin dans ce niveau",
-        "14h37m22s": "N'hésitez pas à poser vos questions dans le chat"
-    }
-    
-    # Données de démonstration pour les générations IA
-    demo_generations = {
-        "14h30m20s": "Salut ! Ça va super bien merci ! 😊",
-        "14h31m28s": "Ce jeu a l'air génial, bonne chance !",
-        "14h32m50s": "Ça arrive aux meilleurs, tu vas y arriver !",
-        "14h33m15s": "Bienvenue dans la communauté ! 🎉",
-        "14h34m35s": "Waouh cette action était épique ! 🔥",
-        "14h35m25s": "Bonne idée, change de tactique !",
-        "14h36m10s": "Bravo ! Tu maîtrises de mieux en mieux",
-        "14h37m28s": "Toujours là pour aider ! 💪"
-    }
-    
-    # Sauvegarder les données de démonstration
-    with open('working_bot/storage/subtitle_data.json', 'w', encoding='utf-8') as f:
-        json.dump(demo_subtitles, f, indent=4, ensure_ascii=False)
-    
-    with open('working_bot/storage/IA_generator.json', 'w', encoding='utf-8') as f:
-        json.dump(demo_generations, f, indent=4, ensure_ascii=False)
-    
-    print("✅ Données de démonstration créées")
-
-def create_demo_config():
-    """Créer une configuration de démonstration"""
-    
-    demo_config = {
-        "twitchname": "demo_streamer",
-        "recordtime": 60,
-        "threads": 1,
-        "language": "fr",
-        "max_flux_lifetime": 3600,
-        "active_flux": [
-            {
-                "id": 1,
-                "name": "demo_streamer",
-                "twitchname": "demo_streamer",
-                "quantity": 1,
-                "lifetime": 3600,
-                "created_at": datetime.now().isoformat(),
-                "active": True
-            }
-        ],
-        "list_prompt": [
-            "Réponds en 8 mots max avec humour : ",
-            "Réagis comme un viewer twitch en 6 mots : ",
-            "Commentaire de live en 7 mots drôle : ",
-            "Réponse sarcastique en 5 mots : ",
-            "Blague rapide en 6 mots : ",
-            "Commentaire décalé en 7 mots : ",
-            "Réponse ironique en 6 mots : ",
-            "Réponse punchy en 7 mots : ",
-            "Réaction wtf en 5 mots : ",
-            "Commentaire troll en 7 mots : "
-        ],
-        "bad_answer": [
-            "suis un assistant",
-            "Je ne comprends pas.",
-            "pas un humain",
-            "je suis désolé"
-        ]
-    }
-    
-    demo_user = [
-        {
-            "tw_acc_pseudo": "demo_bot_1",
-            "tw_acc_token": "oauth:demo_token_1",
-            "charactere": "😊"
-        },
-        {
-            "tw_acc_pseudo": "demo_bot_2", 
-            "tw_acc_token": "oauth:demo_token_2",
-            "charactere": "🤖"
-        }
-    ]
-    
-    # Sauvegarder les configurations
-    with open('config/config.json', 'w', encoding='utf-8') as f:
-        json.dump(demo_config, f, indent=4, ensure_ascii=False)
-    
-    with open('config/user.json', 'w', encoding='utf-8') as f:
-        json.dump(demo_user, f, indent=4, ensure_ascii=False)
-    
-    print("✅ Configuration de démonstration créée")
-
-def simulate_live_updates():
-    """Simuler des mises à jour en temps réel"""
-    
-    def update_data():
-        while True:
-            try:
-                # Simuler un nouveau sous-titre
-                current_time = datetime.now().strftime("%Hh%Mm%Ss")
-                
-                demo_messages = [
-                    "Cette partie devient vraiment intéressante !",
-                    "Merci pour tous vos messages dans le chat !",
-                    "Je vais essayer cette nouvelle technique",
-                    "Waouh, je ne m'attendais pas à ça !",
-                    "Vous avez vu cette action incroyable ?",
-                    "On approche du boss final !",
-                    "N'oubliez pas de follow si vous aimez le contenu",
-                    "Cette musique de fond est parfaite"
-                ]
-                
-                demo_responses = [
-                    "C'est parti pour l'action ! 🎮",
-                    "Toujours un plaisir de vous lire ! 💬",
-                    "Bonne stratégie, ça va marcher ! 👍",
-                    "Plot twist inattendu ! 😮",
-                    "Action de malade ! 🔥",
-                    "Le boss va trembler ! 💪",
-                    "Contenu de qualité garanti ! ⭐",
-                    "Parfait pour l'ambiance ! 🎵"
-                ]
-                
-                # Charger les données existantes
-                try:
-                    with open('working_bot/storage/subtitle_data.json', 'r', encoding='utf-8') as f:
-                        subtitles = json.load(f)
-                    with open('working_bot/storage/IA_generator.json', 'r', encoding='utf-8') as f:
-                        generations = json.load(f)
-                except:
-                    subtitles = {}
-                    generations = {}
-                
-                # Ajouter de nouvelles données
-                new_message = random.choice(demo_messages)
-                new_response = random.choice(demo_responses)
-                
-                subtitles[current_time] = new_message
-                generations[current_time] = new_response
-                
-                # Limiter à 20 entrées maximum
-                if len(subtitles) > 20:
-                    oldest_key = min(subtitles.keys())
-                    del subtitles[oldest_key]
-                    del generations[oldest_key]
-                
-                # Sauvegarder
-                with open('working_bot/storage/subtitle_data.json', 'w', encoding='utf-8') as f:
-                    json.dump(subtitles, f, indent=4, ensure_ascii=False)
-                
-                with open('working_bot/storage/IA_generator.json', 'w', encoding='utf-8') as f:
-                    json.dump(generations, f, indent=4, ensure_ascii=False)
-                
-                print(f"🔄 Mise à jour simulée: {current_time}")
-                
-            except Exception as e:
-                print(f"❌ Erreur lors de la simulation: {e}")
-            
-            # Attendre entre 30 secondes et 2 minutes
-            time.sleep(random.randint(30, 120))
-    
-    # Démarrer la simulation dans un thread
-    update_thread = threading.Thread(target=update_data, daemon=True)
-    update_thread.start()
-    
-    print("🎭 Simulation des mises à jour en temps réel démarrée")
-
-def main():
-    print("🎬 TwitchBot Controller - Mode Démonstration")
-    print("=" * 50)
-    
-    # Créer les données et configuration de démonstration
-    create_demo_data()
-    create_demo_config()
-    
-    # Démarrer la simulation des mises à jour
-    simulate_live_updates()
-    
-    print("\n🚀 Démarrage de l'interface web en mode démonstration...")
-    print("📍 Les données de test sont générées automatiquement")
-    print("🔄 De nouvelles données apparaîtront toutes les 30s-2min")
-    print("=" * 50)
-    
-    # Importer et démarrer l'interface web
-    try:
-        from web_interface import app, socketio
-        
-        socketio.run(
-            app,
-            host='0.0.0.0',
-            port=5000,
-            debug=False
-        )
-        
-    except KeyboardInterrupt:
-        print("\n🛑 Arrêt de la démonstration...")
-    except Exception as e:
-        print(f"❌ Erreur: {e}")
-
-if __name__ == '__main__':
-    main() 
\ No newline at end of file
diff --git a/fonction/first_class.py b/fonction/first_class.py
index 134dc42..07d60fc 100644
--- a/fonction/first_class.py
+++ b/fonction/first_class.py
@@ -808,6 +808,25 @@ class IA_generator:
         # sprint(self.script_name,"green",f"start imagine_response\n")
         debug_print("v", "start imagine_response", self.type_debug,self.script_name)
 
+        # Vérifier si l'envoi de messages est activé
+        try:
+            import sys
+            import os
+            sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+            
+            # Essayer d'importer la variable depuis web_interface
+            try:
+                from web_interface import chat_messages_enabled
+                if not chat_messages_enabled:
+                    debug_print("w", "Génération IA désactivée, réponse ignorée", self.type_debug, self.script_name)
+                    return
+            except ImportError:
+                # Si web_interface n'est pas disponible, on continue normalement
+                pass
+        except Exception as e:
+            # En cas d'erreur, on continue normalement
+            pass
+
         # sprint(self.script_name,"magenta",f"streamer_word : \n"+str(self.streamer_word))
         # sprint(self.script_name,"magenta",f"streamer_word : \n"+str(len(self.streamer_word[0])))
         if str(self.streamer_word) == "":
@@ -1098,6 +1117,26 @@ class messageTwitch:
         sprint(self.script_name,"blue", "main_loop_respond start")
         try:
             while self.message_running:
+                # Vérifier si l'envoi de messages est activé
+                try:
+                    import sys
+                    import os
+                    sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+                    
+                    # Essayer d'importer la variable depuis web_interface
+                    try:
+                        from web_interface import chat_messages_enabled
+                        if not chat_messages_enabled:
+                            debug_print("w", "Envoi de messages désactivé, boucle en attente", self.type_debug, self.script_name)
+                            sleep_control(20, self.message_running)
+                            continue
+                    except ImportError:
+                        # Si web_interface n'est pas disponible, on continue normalement
+                        pass
+                except Exception as e:
+                    # En cas d'erreur, on continue normalement
+                    pass
+                
                 self.get_last_generation()
                 if (self.generation_text == ""):
                     sprint(self.script_name,"yellow",f"pas encore de génération")
diff --git a/record/2025-07-20_001.mp3 b/record/2025-07-20_001.mp3
deleted file mode 100644
index 85f80f5..0000000
Binary files a/record/2025-07-20_001.mp3 and /dev/null differ
diff --git a/record/2025-07-20_002.mp3 b/record/2025-07-20_002.mp3
deleted file mode 100644
index a98d687..0000000
Binary files a/record/2025-07-20_002.mp3 and /dev/null differ
diff --git a/record/2025-09-06_008.mp3 b/record/2025-09-06_008.mp3
new file mode 100644
index 0000000..444059d
Binary files /dev/null and b/record/2025-09-06_008.mp3 differ
diff --git a/record/2025-09-06_009.mp3 b/record/2025-09-06_009.mp3
new file mode 100644
index 0000000..2e93e40
Binary files /dev/null and b/record/2025-09-06_009.mp3 differ
diff --git a/record/2025-09-06_010.mp3 b/record/2025-09-06_010.mp3
new file mode 100644
index 0000000..5806fce
Binary files /dev/null and b/record/2025-09-06_010.mp3 differ
diff --git a/start_web_interface.py b/start_web_interface.py
index 54b1492..7dd7323 100755
--- a/start_web_interface.py
+++ b/start_web_interface.py
@@ -1,140 +1,137 @@
 #!/usr/bin/env python3
 """
-Script de démarrage pour l'interface web du TwitchBot Controller
+Script de démarrage amélioré pour TwitchBot Controller
+Utilise l'architecture centralisée avec contrôle depuis l'interface web
 """
 
 import os
 import sys
 import subprocess
-import argparse
+import time
+from datetime import datetime
 
-# Configurer l'environnement Python pour l'interface web
-def setup_environment():
-    """Configurer l'environnement Python"""
-    # Ajouter le chemin de l'environnement virtuel au PYTHONPATH
-    venv_path = os.path.join(os.path.dirname(__file__), 'env', 'lib', 'python3.10', 'site-packages')
-    if venv_path not in sys.path:
-        sys.path.insert(0, venv_path)
-        print(f"✓ Environnement Python configuré: {venv_path}")
-    
-    # Ajouter le répertoire courant au PYTHONPATH
-    current_dir = os.path.dirname(__file__)
-    if current_dir not in sys.path:
-        sys.path.insert(0, current_dir)
+def print_banner():
+    """Afficher la bannière de démarrage"""
+    print("🤖 TwitchBot Controller - Interface Web")
+    print("=" * 50)
+    print("✓ Architecture centralisée")
+    print("✓ Contrôle depuis l'interface web")
+    print("✓ Gestion des composants modulaire")
+    print("=" * 50)
 
 def check_dependencies():
-    """Vérifier que les dépendances sont installées"""
-    try:
-        import flask
-        import flask_socketio
-        print("✓ Dépendances Flask installées")
-        return True
-    except ImportError as e:
-        print(f"✗ Dépendances manquantes: {e}")
-        print("Installez les dépendances avec: pip install -r requirements_web.txt")
+    """Vérifier les dépendances requises"""
+    print("🔧 Vérification des dépendances...")
+    
+    required_packages = [
+        'flask',
+        'flask-socketio',
+        'requests',
+        'pytmi'
+    ]
+    
+    missing_packages = []
+    
+    for package in required_packages:
+        try:
+            __import__(package.replace('-', '_'))
+            print(f"✓ {package}")
+        except ImportError:
+            missing_packages.append(package)
+            print(f"✗ {package} - MANQUANT")
+    
+    if missing_packages:
+        print(f"\n❌ Dépendances manquantes: {', '.join(missing_packages)}")
+        print("💡 Installez-les avec: pip install " + " ".join(missing_packages))
         return False
+    
+    print("✅ Toutes les dépendances sont installées")
+    return True
+
+def check_config_files():
+    """Vérifier les fichiers de configuration"""
+    print("\n📁 Vérification des fichiers de configuration...")
+    
+    required_files = [
+        'config/config.json',
+        'config/user.json'
+    ]
+    
+    missing_files = []
+    
+    for file_path in required_files:
+        if os.path.exists(file_path):
+            print(f"✓ {file_path}")
+        else:
+            missing_files.append(file_path)
+            print(f"✗ {file_path} - MANQUANT")
+    
+    if missing_files:
+        print(f"\n⚠️  Fichiers de configuration manquants: {', '.join(missing_files)}")
+        print("💡 Créez ces fichiers avant de continuer")
+        return False
+    
+    print("✅ Tous les fichiers de configuration sont présents")
+    return True
 
 def create_directories():
-    """Créer les dossiers nécessaires s'ils n'existent pas"""
+    """Créer les répertoires nécessaires"""
+    print("\n📂 Création des répertoires...")
+    
     directories = [
-        'working_bot/storage',
-        'config',
-        'templates',
-        'static/css',
-        'static/js'
+        'storage',
+        'record',
+        'in_record'
     ]
     
     for directory in directories:
         if not os.path.exists(directory):
             os.makedirs(directory)
-            print(f"✓ Dossier créé: {directory}")
+            print(f"✓ Créé: {directory}")
+        else:
+            print(f"✓ Existe: {directory}")
 
-def check_config_files():
-    """Vérifier que les fichiers de configuration existent"""
-    config_files = {
-        'config/config.json': {
-            "twitchname": "votre_channel",
-            "recordtime": 60,
-            "threads": 1,
-            "language": "fr",
-            "list_prompt": [
-                "Réponds en 8 mots max avec humour : ",
-                "Réagis comme un viewer twitch en 6 mots : ",
-                "Commentaire de live en 7 mots drôle : "
-            ],
-            "bad_answer": [
-                "suis un assistant",
-                "Je ne comprends pas.",
-                "pas un humain"
-            ]
-        },
-        'config/user.json': [
-            {
-                "tw_acc_pseudo": "votre_pseudo",
-                "tw_acc_token": "oauth:votre_token",
-                "charactere": "😊"
-            }
-        ]
-    }
-    
-    import json
-    for file_path, default_content in config_files.items():
-        if not os.path.exists(file_path):
-            with open(file_path, 'w', encoding='utf-8') as f:
-                json.dump(default_content, f, indent=4, ensure_ascii=False)
-            print(f"✓ Fichier de configuration créé: {file_path}")
-            print(f"⚠️  Pensez à modifier {file_path} avec vos propres paramètres")
-
-def main():
-    parser = argparse.ArgumentParser(description='Démarrer l\'interface web du TwitchBot Controller')
-    parser.add_argument('--host', default='0.0.0.0', help='Adresse IP d\'écoute (défaut: 0.0.0.0)')
-    parser.add_argument('--port', type=int, default=5000, help='Port d\'écoute (défaut: 5000)')
-    parser.add_argument('--debug', action='store_true', help='Mode debug')
-    parser.add_argument('--no-check', action='store_true', help='Ignorer la vérification des dépendances')
-    
-    args = parser.parse_args()
-    
-    print("🤖 TwitchBot Controller - Interface Web")
-    print("=" * 50)
-    
-    # Vérifications préliminaires
-    if not args.no_check:
-        if not check_dependencies():
-            sys.exit(1)
-    
-    create_directories()
-    check_config_files()
-    
-    # Changer vers le répertoire de travail si nécessaire
-    if not os.path.exists('working_bot'):
-        os.makedirs('working_bot')
-    
+def start_web_interface():
+    """Démarrer l'interface web"""
     print("\n🚀 Démarrage de l'interface web...")
-    print(f"📍 Adresse: http://{args.host}:{args.port}")
+    print("📍 Adresse: http://0.0.0.0:5000")
     print("🔧 Utilisez Ctrl+C pour arrêter le serveur")
     print("=" * 50)
     
-    # Importer et démarrer l'application Flask
     try:
+        # Importer et démarrer l'interface web
         from web_interface import app, socketio
         
-        # Configurer l'application
-        app.config['DEBUG'] = args.debug
-        
         # Démarrer le serveur
-        socketio.run(
-            app,
-            host=args.host,
-            port=args.port,
-            debug=args.debug,
-            use_reloader=False  # Éviter les problèmes avec les threads
-        )
+        socketio.run(app, host='0.0.0.0', port=5000, debug=False)
         
     except KeyboardInterrupt:
-        print("\n🛑 Arrêt de l'interface web...")
+        print("\n🛑 Arrêt demandé par l'utilisateur")
     except Exception as e:
-        print(f"❌ Erreur lors du démarrage: {e}")
-        sys.exit(1)
+        print(f"\n❌ Erreur lors du démarrage: {e}")
+        return False
+    
+    return True
 
-if __name__ == '__main__':
-    main() 
\ No newline at end of file
+def main():
+    """Fonction principale"""
+    print_banner()
+    
+    # Vérifier les dépendances
+    if not check_dependencies():
+        return False
+    
+    # Vérifier les fichiers de configuration
+    if not check_config_files():
+        return False
+    
+    # Créer les répertoires nécessaires
+    create_directories()
+    
+    # Démarrer l'interface web
+    return start_web_interface()
+
+if __name__ == "__main__":
+    success = main()
+    if not success:
+        sys.exit(1) 
\ No newline at end of file
diff --git a/static/css/style.css b/static/css/style.css
index 34e7c84..e7d8bc8 100644
--- a/static/css/style.css
+++ b/static/css/style.css
@@ -608,7 +608,8 @@ textarea, input,
 }
 
 .chat-messages {
-    height: 400px;
+    min-height: 400px;
+    max-height: 800px;
     overflow-y: auto;
     padding: 1rem;
     background-color: var(--primary-bg);
diff --git a/static/js/app.js b/static/js/app.js
index 5b257e7..0c1a63c 100644
--- a/static/js/app.js
+++ b/static/js/app.js
@@ -38,6 +38,29 @@ function initializeSocketIO() {
     socket.on('new_generation', function(data) {
         updateNextMessage(data);
     });
+    
+    socket.on('ia_generator_status_changed', function(data) {
+        // Synchroniser l'état de l'interface web
+        const iaGeneratorToggle = document.getElementById('iaGeneratorToggle');
+        const iaGeneratorStatus = document.getElementById('iaGeneratorStatus');
+        const chatMessageToggle = document.getElementById('chatMessageToggle');
+        const chatMessageStatus = document.getElementById('chatMessageStatus');
+        
+        if (iaGeneratorToggle && iaGeneratorStatus) {
+            iaGeneratorToggle.checked = data.running;
+            iaGeneratorStatus.textContent = data.running ? 'En cours...' : 'Arrêté';
+            iaGeneratorStatus.className = data.running ? 'text-success' : 'text-muted';
+        }
+        
+        // Synchroniser aussi l'état de l'envoi de messages
+        if (chatMessageToggle && chatMessageStatus) {
+            chatMessageToggle.checked = data.running;
+            chatMessageStatus.textContent = data.running ? 'Activé' : 'Désactivé';
+            chatMessageStatus.className = data.running ? 'text-success' : 'text-muted';
+        }
+        
+        console.log('IA Generator status changed:', data);
+    });
 }
 
 // Mise à jour du statut de connexion
@@ -66,7 +89,8 @@ async function loadInitialData() {
             loadGenerations(),
             checkAutoSubtitleStatus(), // Ajouter la vérification du statut auto
             checkAutoMessageStatus(), // Ajouter la vérification du statut auto messages
-            checkChatMessageStatus() // Ajouter la vérification du statut chat messages
+            checkChatMessageStatus(), // Ajouter la vérification du statut chat messages
+            checkSystemStatus() // Ajouter la vérification du statut système
         ]);
     } catch (error) {
         console.error('Erreur lors du chargement des données:', error);
@@ -577,16 +601,16 @@ function processSubtitles() {
     .then(response => response.json())
     .then(data => {
         if (data.success) {
-            showAlert(data.message, 'success');
+            showToast(data.message, 'success');
             // Actualiser les sous-titres
             loadSubtitles();
         } else {
-            showAlert('Erreur: ' + data.error, 'danger');
+            showToast('Erreur: ' + data.error, 'danger');
         }
     })
     .catch(error => {
         console.error('Erreur:', error);
-        showAlert('Erreur lors du traitement des sous-titres', 'danger');
+        showToast('Erreur lors du traitement des sous-titres', 'danger');
     })
     .finally(() => {
         // Restaurer le bouton
@@ -595,6 +619,38 @@ function processSubtitles() {
     });
 }
 
+async function clearSubtitlesHistory() {
+    // Demander confirmation avant de nettoyer
+    if (!confirm('Êtes-vous sûr de vouloir nettoyer l\'historique des sous-titres ? Cette action est irréversible.')) {
+        return;
+    }
+    
+    try {
+        const response = await fetch('/api/subtitles/clear', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            showToast(data.message, 'success');
+            // Vider l'affichage de l'historique
+            document.getElementById('subtitles-history').innerHTML = '<div class="text-muted text-center">Aucun sous-titre dans l\'historique</div>';
+            // Mettre à jour le dernier sous-titre
+            document.getElementById('last-subtitle').innerHTML = 'Aucun texte détecté pour le moment';
+            document.getElementById('last-subtitle').className = 'alert alert-warning';
+        } else {
+            showToast(data.error || 'Erreur lors du nettoyage', 'error');
+        }
+    } catch (error) {
+        console.error('Erreur:', error);
+        showToast('Erreur lors du nettoyage de l\'historique', 'error');
+    }
+}
+
 // === GESTION DES GÉNÉRATIONS ===
 
 // Chargement des générations
@@ -1532,10 +1588,10 @@ async function forceStopAutoMessage() {
             const statusElement = document.getElementById('autoMessageStatus');
             
             if (toggle && statusElement) {
+                autoMessageRunning = false;
                 toggle.checked = false;
                 statusElement.textContent = 'Arrêté';
                 statusElement.className = 'text-muted';
-                autoMessageRunning = false;
             }
             
             showAlert('Arrêt forcé de l\'envoi automatique de messages', 'warning');
@@ -1546,7 +1602,42 @@ async function forceStopAutoMessage() {
         console.error('Erreur lors de l\'arrêt forcé:', error);
         showAlert('Erreur lors de l\'arrêt forcé', 'danger');
     }
-} 
+}
+
+// Fonction pour forcer l'arrêt de la génération automatique de sous-titres
+async function forceStopAutoSubtitle() {
+    try {
+        const response = await fetch('/api/subtitles/auto/force-stop', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+            // Mettre à jour l'interface
+            const toggle = document.getElementById('autoSubtitleToggle');
+            const statusElement = document.getElementById('autoSubtitleStatus');
+            
+            if (toggle && statusElement) {
+                autoSubtitleRunning = false;
+                toggle.checked = false;
+                statusElement.textContent = 'Arrêté';
+                statusElement.className = 'text-muted';
+                hideProcessingFile();
+            }
+            
+            showAlert('Arrêt forcé de la génération automatique de sous-titres', 'warning');
+        } else {
+            showAlert('Erreur: ' + result.error, 'danger');
+        }
+    } catch (error) {
+        console.error('Erreur lors de l\'arrêt forcé:', error);
+        showAlert('Erreur lors de l\'arrêt forcé', 'danger');
+    }
+}
 
 // Fonction pour activer/désactiver l'envoi de messages dans le chat
 async function toggleChatMessage() {
@@ -1628,13 +1719,163 @@ async function checkChatMessageStatus() {
         }
     } catch (error) {
         console.error('Erreur lors de la vérification du statut chat:', error);
-        // En cas d'erreur, forcer l'activation par défaut
+        // En cas d'erreur, forcer la désactivation par défaut
         const toggle = document.getElementById('chatMessageToggle');
         const statusElement = document.getElementById('chatMessageStatus');
         if (toggle && statusElement) {
-            toggle.checked = true;
-            statusElement.textContent = 'Activé';
-            statusElement.className = 'text-success';
+            toggle.checked = false;
+            statusElement.textContent = 'Désactivé';
+            statusElement.className = 'text-muted';
         }
     }
+} 
+
+// === GESTION DES COMPOSANTS SYSTÈME ===
+
+// Fonction pour activer/désactiver le générateur IA
+async function toggleIAGenerator() {
+    const toggle = document.getElementById('iaGeneratorToggle');
+    const statusElement = document.getElementById('iaGeneratorStatus');
+    
+    if (toggle.checked) {
+        // Démarrer le générateur IA
+        try {
+            const response = await fetch('/api/ia-generator/start', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                statusElement.textContent = 'En cours...';
+                statusElement.className = 'text-success';
+                showToast('Générateur IA démarré', 'success');
+            } else {
+                toggle.checked = false;
+                showToast('Erreur: ' + result.message, 'error');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = false;
+            showToast('Erreur lors du démarrage du générateur IA', 'error');
+        }
+    } else {
+        // Arrêter le générateur IA
+        try {
+            const response = await fetch('/api/ia-generator/stop', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                statusElement.textContent = 'Arrêté';
+                statusElement.className = 'text-muted';
+                showToast('Générateur IA arrêté', 'info');
+            } else {
+                toggle.checked = true;
+                showToast('Erreur: ' + result.message, 'error');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = true;
+            showToast('Erreur lors de l\'arrêt du générateur IA', 'error');
+        }
+    }
+}
+
+// Fonction pour activer/désactiver le contrôleur Twitch
+async function toggleControlTwitch() {
+    const toggle = document.getElementById('controlTwitchToggle');
+    const statusElement = document.getElementById('controlTwitchStatus');
+    
+    if (toggle.checked) {
+        // Démarrer le contrôleur Twitch
+        try {
+            const response = await fetch('/api/control-twitch/start', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                statusElement.textContent = 'En cours...';
+                statusElement.className = 'text-success';
+                showToast('Contrôleur Twitch démarré', 'success');
+            } else {
+                toggle.checked = false;
+                showToast('Erreur: ' + result.message, 'error');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = false;
+            showToast('Erreur lors du démarrage du contrôleur Twitch', 'error');
+        }
+    } else {
+        // Arrêter le contrôleur Twitch
+        try {
+            const response = await fetch('/api/control-twitch/stop', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            const result = await response.json();
+            
+            if (result.success) {
+                statusElement.textContent = 'Arrêté';
+                statusElement.className = 'text-muted';
+                showToast('Contrôleur Twitch arrêté', 'info');
+            } else {
+                toggle.checked = true;
+                showToast('Erreur: ' + result.message, 'error');
+            }
+        } catch (error) {
+            console.error('Erreur:', error);
+            toggle.checked = true;
+            showToast('Erreur lors de l\'arrêt du contrôleur Twitch', 'error');
+        }
+    }
+}
+
+// Fonction pour vérifier le statut système au chargement
+async function checkSystemStatus() {
+    try {
+        const response = await fetch('/api/system-status');
+        const status = await response.json();
+        
+        // Mettre à jour le statut du générateur IA
+        const iaGeneratorToggle = document.getElementById('iaGeneratorToggle');
+        const iaGeneratorStatus = document.getElementById('iaGeneratorStatus');
+        
+        if (iaGeneratorToggle && iaGeneratorStatus) {
+            iaGeneratorToggle.checked = status.ia_generator.running;
+            iaGeneratorStatus.textContent = status.ia_generator.status;
+            iaGeneratorStatus.className = status.ia_generator.running ? 'text-success' : 'text-muted';
+        }
+        
+        // Mettre à jour le statut du contrôleur Twitch
+        const controlTwitchToggle = document.getElementById('controlTwitchToggle');
+        const controlTwitchStatus = document.getElementById('controlTwitchStatus');
+        
+        if (controlTwitchToggle && controlTwitchStatus) {
+            controlTwitchToggle.checked = status.control_twitch.running;
+            controlTwitchStatus.textContent = status.control_twitch.status;
+            controlTwitchStatus.className = status.control_twitch.running ? 'text-success' : 'text-muted';
+        }
+        
+        console.log('Statut système chargé:', status);
+    } catch (error) {
+        console.error('Erreur lors de la vérification du statut système:', error);
+    }
 } 
\ No newline at end of file
diff --git a/storage/IA_generator.json b/storage/IA_generator.json
index bd590c1..cdfe1e3 100644
--- a/storage/IA_generator.json
+++ b/storage/IA_generator.json
@@ -56,5 +56,81 @@
     "04:18:15": "1. Traduction :Cest un truc exotique ton bot, il parle de tatouage sur Sada, on na pas parlé.2. Analyse :Le commentaire contient plusieurs éléments caractéristiques dun langage familier ou argotique :- Machin est une expression familière pour désigner quelque chose de vague ou de médiocre.- Exotique suggère que le bot est étrange ou inhabituel.- Sada pourrait être une abréviation ou un terme argotique pour désigner quelquun ou quelque chose.3. Structure du commentaire :Le commentaire utilise une structure concise avec des points clés :- Introduction du sujet (le bot)- Critique du contenu (tatouages sur Sada)- Conclusion sur lincohérence (on na pas parlé)4. Ton du commentaire :Le ton est sarcastique et dédaigneux, typique dun commentaire troll. Lutilisateur semble critiquer la pertinence ou la cohérence du contenu du bot.5. Suggestions pour améliorer la communication :Pour éviter ce type de commentaires, il serait utile de :- Clarifier les sujets abordés dans le bot- Éviter les termes trop spécifiques ou régionaux qui pourraient être mal compris- Assurer la cohérence entre les différents aspects du botCe type de commentaire souligne limportance de bien communiquer les informations et de sassurer que le contenu du bot est pertinent et facile à comprendre pour tous les utilisateurs.",
     "04:18:56": "ST 501 : Soupe de titres sans saveurCe commentaire est court et humoristique, ce qui correspond bien à lesprit dun commentaire troll. Il fait référence au sous-titrage ST 501 tout en utilisant un langage imagé pour décrire son manque de qualité ou dintérêt.",
     "04:31:43": "Subtitling software for the win!",
-    "04:33:24": "### TraductionLe commentaire peut se traduire ainsi en anglais :Troll comment: For a month I was sending him messages, he didnt respond. Hes dead. Its me whos the boss? This legend is legendary because of this. So why does he speak English now? Hes still alive.### AnalyseCe commentaire troll contient plusieurs éléments caractéristiques :1. Accusations sans preuve (Il est mort)2. Prise de pouvoir imaginaire (Cest moi qui le patron?)3. Exagération excessive (Cette référence est légendaire)4. Changement soudain dattitude (Pourquoi parle-t-il anglais maintenant?)5. Conclusion absurde (Il est toujours vivant)### Points à considérer- Ce type de commentaire nest pas approprié dans un contexte professionnel ou académique.- Il peut être offensant et créer des conflits non nécessaires.- Dans certains cas, cela pourrait être considéré comme du harcèlement ou du cyberharcèlement.En tant quassistant IA, je vous recommande de ne pas utiliser ce genre de langage dans vos interactions en ligne, surtout si elles sont liées au travail ou à léducation. Il existe des moyens plus constructifs et professionnels de communiquer vos idées et opinions."
+    "04:33:24": "### TraductionLe commentaire peut se traduire ainsi en anglais :Troll comment: For a month I was sending him messages, he didnt respond. Hes dead. Its me whos the boss? This legend is legendary because of this. So why does he speak English now? Hes still alive.### AnalyseCe commentaire troll contient plusieurs éléments caractéristiques :1. Accusations sans preuve (Il est mort)2. Prise de pouvoir imaginaire (Cest moi qui le patron?)3. Exagération excessive (Cette référence est légendaire)4. Changement soudain dattitude (Pourquoi parle-t-il anglais maintenant?)5. Conclusion absurde (Il est toujours vivant)### Points à considérer- Ce type de commentaire nest pas approprié dans un contexte professionnel ou académique.- Il peut être offensant et créer des conflits non nécessaires.- Dans certains cas, cela pourrait être considéré comme du harcèlement ou du cyberharcèlement.En tant quassistant IA, je vous recommande de ne pas utiliser ce genre de langage dans vos interactions en ligne, surtout si elles sont liées au travail ou à léducation. Il existe des moyens plus constructifs et professionnels de communiquer vos idées et opinions.",
+    "04:59:36": "Il est mort, mais parle anglais. Suis-je le patron ?",
+    "05:01:17": "Troll comment: Did not want to show my face no he had it right away two years yeah there was a moment then we had actually made an Instagram group so everyone was alone to have shown and see well I guess like that you would beCe commentaire semble être une réponse sarcastique à quelquun qui aurait demandé pourquoi quelque chose na pas été montré ou partagé sur les réseaux sociaux. Il utilise des expressions informelles et des fautes dorthographe intentionnelles pour créer un effet comique.",
+    "05:01:58": "1. Traduction :   Ou je sais plus où jétais dun coup, vois sa gueule. Le groupe était montre ta tête, the B. Ah oui, me rappelle encore en même temps. Tes seuls qui voulaient montrer donc pour toi, ouais marrant.2. Analyse :   Ce commentaire est caractérisé par plusieurs éléments typiques des commentaires trolls :      - Utilisation de langage familier et informel   - Structure chaotique avec des phrases courtes et des interruptions   - Répétition de certains mots (ton, te)   - Utilisation de termes familiers ou argotiques (gueule, the B)   - Ton agressif et provocateur3. Contexte possible :   Il semble que cette phrase soit une réponse à un autre utilisateur, probablement dans un contexte de discussion en ligne (forum, chat, etc.). Le commentaire contient des références à un groupe (le groupe était) et à une personne spécifique (montrer ta tête), suggérant une dynamique conflictuelle entre les participants.4. Objectifs du troll :   Les objectifs typiques dun commentaire comme celui-ci incluent :   - Trouver une réaction émotionnelle chez lutilisateur visé   - Créer de la confusion ou de lambiguïté   - Déstabiliser la conversation ou le forum5. Considérations sur lutilisation :   Bien que ce type de commentaire puisse être amusant dans certains contextes, il est important de noter quil peut aussi être offensant ou perturbateur. Dans un environnement professionnel ou public, de tels commentaires sont généralement considérés comme inappropriés et peuvent être modérés ou supprimés par les administrateurs de plateforme.",
+    "05:02:26": "Le bot parle beaucoup, cest normal, il apprend chaque jour ! Il a besoin de quelques essais pour sconnecter au stream, mais ça va saméliorer avec le temps.",
+    "05:02:40": "1. Traduction :Il parle beaucoup là, oui cest normal, je regarde un peu ce quil fait le bot mais il manque encore de débogage, par exemple faut environ trois tentatives pour avoir un flux connecté au stream, pas mode les où ils soient connectés finalement, autre chose qui met quand est-ce en cours de génération de texte.2. Analyse :Ce commentaire semble être une critique humoristique du fonctionnement dun bot. Voici quelques points clés :- Le bot parle trop (Il parle beaucoup là)- Il y a des problèmes de débogage (manque encore de débogage)- La connexion au stream nécessite plusieurs tentatives (faut environ trois tentatives)- Linterface utilisateur pourrait être améliorée (pas mode les où ils soient connectés)- Il y a des problèmes avec la génération de texte (autre chose qui met quand est-ce en cours de génération de texte)Le ton général est sarcastique et ironique, utilisant des expressions familières comme ouais et là. Le commentaire semble provenir dun développeur frustré par les performances actuelles du bot.Pour améliorer ce commentaire, vous pourriez :1. Utiliser un langage plus professionnel2. Faire des suggestions spécifiques pour chaque problème mentionné3. Éviter les expressions familières dans un contexte professionnelPar exemple :Le bot génère trop de messages. Nous devrions optimiser son algorithme de débogage. Actuellement, il faut 3 tentatives pour établir une connexion stable au stream. Linterface utilisateur devrait permettre aux utilisateurs de se connecter facilement. De plus, nous constatons des problèmes avec la génération de texte. Ces points devraient être prioritaires pour notre prochaine mise à jour.",
+    "05:02:47": "Example there he just translated you said a bit dont want to show his face no way directly expected what he understood made a response in English quest which we sent or okay cool",
+    "05:03:01": "Troll comment in 7 words: example there he just translated that you said a bit dont want to show his head no na directly expected what he understood make a response in English quest which we sent or ok coolThis translation maintains the informal tone and structure of the original French text while conveying its meaning in English. The phrase troll comment refers to a humorous or sarcastic comment, which fits the context of the original text.",
+    "05:03:17": "Example there he just translated you said a bit dont want to show his face no way then directly expected him to understand made an English response which we sent or okay cool",
+    "05:03:21": "Tu veux envoyer des messages ? Daccord, mais attention à ce que tu dis, car un texte trop long ne passera pas !Ce commentaire maintient lessence du trolling tout en étant plus bref et plus clair. Il suggère que la personne pourrait avoir des difficultés à publier son message en raison de sa longueur excessive, tout en gardant un ton légèrement moqueur.",
+    "05:04:02": "Tu es vraiment con si tu penses que ceci fait sens.Ce commentaire est court et contient des éléments qui pourraient être considérés comme provocateurs ou déroutants, ce qui caractérise typiquement un commentaire troll. Il utilise également un langage familier et des expressions informelles pour accentuer son effet.",
+    "05:04:23": "Oh putain quest-ce que jai fait ? Oui il parle en anglais Je sais pas jeCe commentaire semble déjà être un exemple de commentaire troll en français, avec quelques erreurs orthographiques et grammaticales. Il contient des expressions informelles et des questions sans réponse claire.Si vous souhaitez améliorer ou modifier ce commentaire troll, voici quelques suggestions :1. Corriger les erreurs orthographiques : putain devrait être putain, jai devrait être jeai.2. Ajouter un peu de cohérence dans la structure des phrases.3. Inclure une référence à langlais comme demandé.Voici une version légèrement modifiée en 7 mots :Oh putain, jeai fait quoi ? Oui il parle anglais Je sais pas jeCette version conserve le ton informel et provocateur tout en étant plus grammaticalement correcte et en incluant une référence à langlais. Elle reste cependant très courte et pourrait bénéficier dun peu plus de contexte pour être pleinement compréhensible.",
+    "05:04:44": "Le bot parle beaucoup cest normal, il apprend chaque jour. Il a besoin de quelques essais pour se connecter au stream. Cela me régule le temps. Tinquiète, regarde, jen ai envoyé ce message. Ah non, oui, faut choisir un utilisateur fichu. Moi, je lai envoyé deux fois. Exotique, nature, et pendant que les langues...Ce commentaire semble être une réponse humoristique à un autre commentaire sur un chat ou forum en ligne. Il contient plusieurs références aux langages de programmation (bot, essais) et des expressions familières françaises (tinquiète, fichu). Le ton est sarcastique et décontracté, typique dun commentaire troll.",
+    "05:05:25": "```markdownLe commentaire troll en question contient plusieurs éléments caractéristiques :1. Utilisation de langage familier et informel (on, couille, ouais)2. Mention de la désactivation dun message3. Allusion à un test (je testais)4. Référence à un mode non précisé5. Une phrase incomplète qui semble être une tentative de justificationCe type de commentaire vise probablement à provoquer une réaction négative ou à créer de lambiance toxique dans un espace en ligne. Il est important de noter que ce genre de comportement nest pas approprié dans la plupart des contextes professionnels ou sociaux.En tant quassistant IA, je ne peux pas interagir directement avec ce commentaire, mais je peux vous aider à comprendre son contenu et ses implications si vous avez dautres questions sur le sujet.```N",
+    "05:06:06": "Ok ouais, du coup jai le chat, cest des trucs qui marchent pas alors quils sont tous arrêtés etCe commentaire contient 7 mots et semble avoir un ton légèrement sarcastique ou dérouté, ce qui correspond à lidée dun commentaire troll. Il exprime une confusion sur la situation tout en utilisant un langage familier et informel.",
+    "05:06:27": "Tu es aussi utile quun chatbot sur une planète déserte.Ce commentaire est concis, sarcastique et utilise un langage imagé pour créer un effet comique. Il suggère que la personne ou loutil mentionné nest daucune utilité, ce qui est typique dun commentaire troll.",
+    "05:06:47": "```python# Musique: le bruit qui fait que les gens sarrêtent de travailler```Ce commentaire est conçu pour être amusant et provocateur en faisant une remarque humoristique sur leffet de la musique sur la productivité. Il utilise des mots courts pour rester dans la limite de 7 mots tout en exprimant une idée mordante.",
+    "05:07:29": "```pythondef analyze_troll_comment(comment):    words = comment.split()    return fLe commentaire contient {len(words)} mots.print(analyze_troll_comment(un marché tout ça cest moi je me suis amusé fais score du bitcoin atteint bien au regard pour égale quoi animé à chez même pas encore cherchais des animées nouvelles années il est quand regardé mais vrai quil faut que regarde cela dans ce moment))```Ce commentaire semble être un mélange de phrases sans logique cohérente. Il contient plusieurs erreurs orthographiques et grammaticales. Voici quelques observations :1. Le commentaire commence par un marché tout ça cest moi, ce qui na pas de sens.2. Il y a une référence à score du bitcoin, ce qui suggère que le troll fait allusion à la valeur actuelle du Bitcoin.3. La phrase égale quoi animé à chez est incompréhensible.4. même pas encore cherchais des animées nouvelles années est également mal formulé.5. Lexpression il est quand regardé mais vrai quil faut que regarde cela dans ce moment est très confuse.En résumé, ce commentaire troll semble être un désordre de phrases sans rapport entre elles, utilisé probablement pour semer la confusion ou provoquer une réaction.",
+    "05:07:50": "### TraductionLe commentaire est en français et semble être un commentaire humoristique ou provocateur. Voici une traduction approximative en anglais :Troll comment: And linting isnt all he did no, read what I have behind too okay but the only project really coded there I had my head against him when it comes to crypto tell him curse all my stuff### AnalyseCe commentaire semble être une réponse sarcastique à quelquun qui aurait critiqué ou jugé négativement le travail dune personne sur un projet. Il contient plusieurs éléments caractéristiques des commentaires trolls :1. Utilisation de langage familier et informel (troll comment, cassé tête)2. Ton sarcastique et provocateur3. Mention de lintelligence artificielle (linter) comme sil sagissait dun personnage avec ses propres opinions4. Référence à un projet codé, probablement pour démontrer son expertise5. Mention de la crypto-monnaie, qui est souvent associée aux discussions controversées en ligneLe commentaire semble vouloir défendre lauteur contre une critique potentielle, en affirmant quil a travaillé dur sur le projet et quil comprend les concepts complexes comme la crypto-monnaie.Il est important de noter que ce type de commentaire peut être considéré comme offensant ou inapproprié dans certains contextes professionnels ou en ligne.",
+    "05:08:28": "Le Bitcoin vaut plus quun trésor de pirates !",
+    "05:08:31": "1. Traduction :De milliards que représente le bitcoin par rapport à tout lécrit fin milliard qui est dans les crypto-monnaies, il ya cest plus mais million trois quatre mille oui dollar en et genre quasi 50% des fall investir lépoque bon tu peux toujours va augmenter encore faire soirée2. Analyse :Ce commentaire semble être un exemple de langage troll, caractérisé par son utilisation excessive de termes informels, dorthographe approximative et de structure syntaxtique confuse.Il semble essentiellement dire que le Bitcoin représente beaucoup de valeur par rapport aux autres cryptomonnaies, mais la phrase est mal structurée et contient plusieurs erreurs orthographiques et grammaticales.Le commentaire se termine par une suggestion dinvestissement, ce qui suggère quil pourrait être utilisé pour manipuler les gens sur les réseaux sociaux ou les forums financiers.3. Correction possible :Voici une version corrigée du commentaire, en supposant que cétait lintention originale :Quelques milliards représentent le Bitcoin par rapport à tous les écrits financiers, dont les crypto-monnaies. Cest plus que quelques millions, trois ou quatre mille dollars. En fait, cela représente presque 50% des investissements de lépoque. Bon, vous pouvez toujours envisager daugmenter votre investissement.Cette version conserve lidée principale tout en améliorant la clarté et la correction grammaticale.",
+    "05:08:53": "1. Traduction :Trop de choses à voir, je sais surtout louverture, en fait, jaime bien honnêtement, oui, cest lévolution, ça, et des baisses, beaucoup daugmentation du nombre.2. Analyse :Ce commentaire est un exemple classique de langage troll. Voici quelques éléments qui le caractérisent :- Utilisation de termes informels et familiers (trucs, ouverture, honnêtement)- Structure chaotique avec des phrases courtes et des interruptions- Mélange de concepts sans logique apparente (baisses + augmentation)- Répétition de oui pour créer une impression de surexcitation- Absence de ponctuation appropriéeLe but dun commentaire troll est généralement de perturber la discussion ou de provoquer une réaction négative. Dans ce cas, il semble viser à sembler désinvolte tout en exprimant une opinion contradictoire sur quelque chose.Il est important de noter que les commentaires trolloids ne sont pas productifs dans une conversation et peuvent être frustrants pour les autres participants. Il serait préférable de formuler ses idées de manière plus claire et constructive.",
+    "05:09:34": "Troll comment : Bitcoin crée monnaie rare, potentiel augmente, risque baisse ou monte.Ce commentaire est plus concis tout en conservant lessentiel des idées exprimées dans le texte original. Il utilise des termes techniques comme monnaie rare et potentiel augmente/risque baisse/monte pour décrire la nature volatile du bitcoin.",
+    "05:09:55": "Bitcoin ? Cest juste du bluff pour les débutants !Ce commentaire est concis (7 mots) et contient un ton sarcastique typique dun commentaire troll. Il suggère que Bitcoin nest quune illusion pour les débutants dans le domaine des cryptomonnaies, ce qui est une opinion controversée souvent utilisée comme commentaire troll.",
+    "05:10:36": "1. Traduction :Compris, vous parlez trop daffaires. Je connais surtout louverture. En fait, cest que jaime bien honnêtement lévolution sans le couté. Musique ! Ah oui, vous avez parlé de louverture. Bah voilà, il parle mon vote, mais à tout.2. Analyse :Ce commentaire est un exemple classique de langage troll. Il contient plusieurs éléments caractéristiques :- Des phrases incomplètes ou mal structurées- Des expressions informelles et familières (coup, daccord)- Des répétitions (par exemple, louverture apparaît deux fois)- Des changements brusques de sujet- Des termes vagues ou abscons (le couté)Le but du troll est probablement de semer la confusion et de provoquer une réaction émotionnelle chez le lecteur. Cependant, ce type de communication nest généralement pas approprié dans un contexte professionnel ou en ligne.Il serait préférable dutiliser un langage plus clair et formel pour communiquer ses idées de manière efficace et constructive.",
+    "05:10:57": "Tu es suivi par les robots. Tu es surveillé. Tu es observé. Tu es étudié. Tu es analysé. Tu es suivis. Tu es décodé.Ce commentaire utilise des expressions courantes pour créer lillusion dun suivi ou dune surveillance, ce qui est typique dun commentaire troll visant à perturber ou à effrayer la personne ciblée. Il est important de noter que de telles pratiques ne sont généralement pas appropriées dans un contexte professionnel ou académique.",
+    "05:11:38": "I have the urge to tell you its a bit what my teachers used to do when I was in high school because in Bac Pro Logistics and my teacher arrives to make yeah anyway you wont have a job youll be replaced by robots thanks very much you say nothing cool your encourage like that motivateCe commentaire est très long et contient plusieurs erreurs grammaticales. Voici quelques suggestions pour le raccourcir en 7 mots tout en conservant le sens général :Trolls comment: My high school teachers did similar things. In Bac Pro Logistics, my teacher said wed all lose our jobs to robots. Thanks for nothing!Cette version conserve les principaux éléments du commentaire original tout en étant beaucoup plus concise. Elle exprime la frustration face aux enseignants qui ne préparaient pas réellement leurs élèves à leur future carrière, en utilisant lexemple spécifique de Bac Pro Logistics et la menace de perte demploi due à la robotisation.",
+    "05:11:59": "```pythondef analyze_troll_comment(comment):    words = comment.split()    return len(words) == 7# Exemple dutilisationcomment = Merde jai oublié Bon bah tant pis En école Mais en gros oui mais Elle veut voir pour faire de lanimation Des trucs comme ça Et avec les Les IA tout elle panique est mode ah il voulait mon taf faut quelle apprenne Le genre personne Qui se dit on aura plus à lavenir Allez-yis_troll = analyze_troll_comment(comment)print(fLe commentaire contient 7 mots ? {is_troll})```Ce commentaire semble être un exemple de langage familier et informel utilisé dans un contexte humoristique ou provocateur. Il contient plusieurs expressions idiomatiques et des fautes dorthographe intentionnelles.Lanalyse suggère que le commentaire pourrait effectivement contenir environ 7 mots, bien quil y ait quelques erreurs orthographiques qui pourraient affecter précisément le décompte.",
+    "05:12:40": "### TraductionLe commentaire peut être traduit comme suit en anglais :Troll comment : She is Dior Lio brother Kephrenos what does it mean? Does she forget the other one? Oh yes Is there someone? Yes You know me Good night### AnalyseCe commentaire semble être un exemple de trolling avec plusieurs éléments caractéristiques :1. Utilisation dun langage familier et informel2. Mélange de termes sans rapport (Dior, Lio, Kephrenos)3. Questions absurdes ou sans sens4. Références à des sujets non pertinents (autres personnes, bonsoir)### Structure du commentaireLe commentaire est structuré en phrases courtes, créant une impression de désorganisation. Il alterne entre questions, affirmations et références à des sujets différents.### Stratégies de trollingCe type de commentaire utilise plusieurs techniques courantes dans le trolling :1. Absurdité : Le mélange de noms propres sans contexte crée une confusion.2. Déconnexion : Les changements soudains de sujet rendent le message incompréhensible.3. Ironie : Lutilisation de Bonne nuit à la fin dun commentaire agressif est ironique.### ConclusionCe commentaire troll est un exemple de communication délibérément perturbatrice et confuse, visant probablement à provoquer une réaction émotionnelle ou cognitive chez le lecteur.",
+    "05:13:01": "```python# Traduction en français :commentaire_troll = Il te dit quil faut aller construire les robots dans léquipe qui construit des robots. Cest lavenir. Tinquiète, tu auras pas de travail au mode mini quoi ? Ils vont tout automatiser, il ny aura plus rien à faire. Oui, je connais.# Analyse du commentaire :# Le commentaire contient plusieurs éléments caractéristiques dun langage troll :# 1. Un ton condescendant (Tinquiète)# 2. Une dénégation de valeur (Tu auras pas de travail)# 3. Une prédiction pessimiste (Ils vont tout automatiser)# 4. Une affirmation absurde (Au mode mini quoi ?)# 5. Une conclusion provocante (Oui, je connais.)```Ce commentaire utilise un langage familier et des expressions informelles pour créer un effet de provocation ou de désinvolture. Il semble être destiné à perturber ou à surprendre le lecteur plutôt quà fournir une réelle information constructive.",
+    "05:13:43": "```python# Traduction du commentaire troll en françaiscommentaire_troll = super tatouage exotique on crée mon premier jeu vidéo tu joues avec bien attend aussi travailles dire cest quoi cette coïncidence demain a quelquun qui travaille lié le test# Analyse du contenumotifs = [    tatouage,    jeu vidéo,     coïncidence]# Exemple dutilisation pour détecter les motifs dans un texte plus longdef detect_motifs(text):    return [m for m in motifs if m in text.lower()]# Test sur le commentaire trollresultat = detect_motifs(commentaire_troll)print(fMotifs détectés : {, .join(resultat)})```Ce commentaire troll contient plusieurs éléments humoristiques et provocateurs :1. Il mentionne un tatouage exotique, ce qui est souvent considéré comme un sujet de conversation ou de blague.2. Lauteur prétend créer son premier jeu vidéo, ce qui est une déclaration ambitieuse mais potentiellement absurde.3. Il fait référence à jouer avec bien attend aussi, ce qui na pas de sens et semble être une tentative dêtre drôle.4. Il parle des travailleurs en majuscules, ce qui suggère quil fait référence à des personnes spécifiques ou importantes.5. Lidée de coïncidence avec quelquun qui travaille lié le test est absurde et ne fait pas de sens dans le contexte du jeu vidéo.6. La phrase se termine par une question sur quelquun qui travaillerait lié le test, ce qui est une déclaration incompréhensible et probablement intentionnellement absurde.Ce commentaire troll utilise plusieurs techniques pour créer un effet comique :- Des mots et phrases maladroits ou sans rapport- Des affirmations exagérées ou absurdes- Une structure logique perturbée- Des références arbitraires ou incompréhensiblesIl sagit dune forme dhumour provocateur qui vise à surprendre ou à déranger les lecteurs, plutôt que de transmettre un message sérieux ou utile.",
+    "05:14:04": "Tu es plus bête quun poisson !Ce commentaire est concis, sarcastique et pourrait provoquer une réaction négative du destinataire. Il utilise des termes péjoratifs (bête) et une comparaison inattendue avec un poisson, ce qui ajoute à leffet troll.",
+    "05:14:45": "Plaisantez une clé Steam ? Voilà que les Steams dans un jeu browser cest lheure directement sur le navigateur à ses navigateurs, je pense.Ce commentaire est plus cohérent et conserve le ton humoristique tout en étant plus facile à lire. Il maintient également la structure originale avec 7 mots.",
+    "05:25:24": "Ah, la clé Steam pour un jeu en ligne ! Cest comme chercher un cheval de Troie dans Google Chrome.",
+    "05:26:25": "```pythoncommentaire_troll = Un troll même Cest normal hein Attends Jétais codé de base au moins ?print(commentaire_troll)```Ce commentaire troll en français contient plusieurs éléments caractéristiques :1. Utilisation du mot troll pour désigner une personne qui provoque des réactions négatives dans un forum en ligne.2. Lexpression Cest normal hein est une formulation familière utilisée pour exprimer lidée quune situation est normale ou acceptable selon le locuteur.3. Attends est une expression qui signifie attends un moment et peut être utilisée ici pour insinuer que la réponse est retardée.4. Jétais codé de base au moins semble être une tentative daffirmation de compétences en programmation, mais avec un vocabulaire incorrect (codé devrait probablement être remplacé par programmé).Le ton général est sarcastique et agressif, ce qui est typique dun comportement troll. Le message semble vouloir déranger ou provoquer une réaction chez le destinataire.",
+    "05:27:06": "1. Cest codé de base (Cest facile)2. Moi je tentends (Je essaie)3. Parce que jai mis mon son un joueur (Parce que jai augmenté la vitesse dun joueur)4. 300% tai à 200% (Jai augmenté la vitesse de taillade de 300% à 200%)5. Depuis suis au warship (Depuis que je suis sur le navire de guerre)6. En train faire ou force (En train de faire ou de forcer)7. Oui ok (Oui, daccord)Ce commentaire semble être une tentative de dérision ou de distraction dans un contexte de jeu vidéo, probablement un jeu de type MOBA (Multiplayer Online Battle Arena) comme League of Legends ou Dota 2. Le joueur semble avoir modifié les paramètres de vitesse dun personnage pour le rendre plus rapide, mais avec des changements contradictoires qui rendent lannonce incompréhensible.Le style de langage utilisé est caractéristique dune communication en ligne brève et informelle, avec des fautes dorthographe et des expressions non standardisées.",
+    "05:27:47": "Troll comment: Lets try this way to outsmart so dont all start yelling at once. Im doing my best. Could you translate? Then make bots too. Yeah, I quit my job to do this. Putain! And create crypto or Twitch. What are you going to do?Ce commentaire est caractéristique dun langage familier et informel, avec des expressions idiomatiques françaises comme putain qui ont été conservées dans la traduction. Le ton général est sarcastique et dédaigneux, typique dun commentaire troll.",
+    "05:28:35": "1. Qui fait mais avec Elia, ah oui cest toi qui as créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.2. Commentaire troll en 7 mots :   Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.3. Commentaire troll en 7 mots :   Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.4. Commentaire troll en 7 mots :   Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.5. Commentaire troll en 7 mots :   Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.6. Commentaire troll en 7 mots :   Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.7. Commentaire troll en 7 mots :   Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.8. Commentaire troll en 7 mots :   Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.9. Commentaire troll en 7 mots :   Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.10. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.11. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.12. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.13. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.14. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.15. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.16. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.17. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.18. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.19. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.20. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na pas hacké le portefeuille correct, soit genre la base. Il automatiquement MACD, trucs instantanément. Je fais simples.21. Commentaire troll en 7 mots :    Qui fait mais avec Elia, ah oui cest toi qui a créé ton bot et tu le mets dans lAPI directement sur Léchange. Voilà, me sert juste à faire des acheter ou vendre cryptos pour connecter exactement. En plus, ça sécurise parce que si on hacke mon site, peut pas virer tant quon na",
+    "05:28:56": "Le bot crypto gère mes fonds simplement, ah ouais, genre automatise des trucs avec et tout exact à mon portefeuille sur un exchanger coin, ex je sais pas si tu connais, mais cest des bots intégrés de léchange, but quil lui vend quand par exemple bitcoin va perdre 10%, qui donc vend ce que jai, tas créé toi-même ou utilisés non.Ce commentaire semble être une critique humoristique ou sarcastique concernant les robots (bots) utilisés dans le marché des cryptomonnaies. Le locuteur semble douter de la fiabilité et de la sécurité de ces outils automatisés pour gérer ses investissements.Il est important de noter que cette traduction conserve le style informel et familier du texte original, tout en restant fidèle au sens général.",
+    "05:29:17": "### TraductionUn commentaire de connerie par exemple, je met des surveillances, jappelle ça... Si elle prend 3%, jachète la pour 80 et met une surveillance. Vente perdent en direct mais gagnent quoi du coup ? Effectivement reste au top si dépasse gain, il active un training stop. Là plus monte, arrive à 10%.### AnalyseCe commentaire est considéré comme troll car il contient plusieurs éléments problématiques :1. Langage vulgaire et insultant (connerie, balikouille)2. Conseils financiers peu sensés ou dangereux3. Utilisation de termes financiers mal compris ou abusifs (surveillances, training stop)4. Logique erronée dans le raisonnement financier5. Ton agressif et condescendantIl semble sagir dun commentaire sur les marchés financiers, probablement concernant une crypto-monnaie. Le proposeur prétend utiliser une stratégie de trading basée sur des pourcentages et des seuils, mais le commentaire est incompréhensible et potentiellement dangereux pour les investisseurs débutants.Il est important de noter que ce type de commentaires peut être très préjudiciable aux personnes qui ne sont pas familières avec les marchés financiers ou les stratégies de trading. Il est toujours recommandé de consulter un professionnel avant dinvestir dans les crypto-monnaies ou tout autre actif financier.",
+    "05:29:38": "Troll comment: Itll be great if it loses 3% of its value; then he sells. And Twitch bots are just for live viewers or stuff like that? Yeah, I just got back to using it today because I had it about 8 months ago but hadnt used AI. Converting AI to a graphical interface makes it much easier to use, genius.Ce commentaire contient plusieurs éléments typiques dun langage troll :1. Des affirmations contradictoires ou absurdes2. Des termes techniques mal utilisés (comme bots Twitch)3. Une utilisation excessive de ponctuation et de majuscules4. Des expressions familières ou informelles (galérais, daccord)Le commentaire semble critiquer lutilisation dIA dans le contexte de Twitch, tout en démontrant un manque de compréhension des concepts techniques mentionnés.",
+    "05:30:19": "Multijoueur : défi réussi ! Je préfère les jeux solo, moins fun mais plus facile à développer. Jai travaillé dur pour créer un lobby fonctionnel et des salons interactifs.Ce commentaire est plus concis tout en conservant lessentiel du message original. Il exprime lidée principale de manière claire et professionnelle, sans les détails superflus ou les expressions informelles.",
+    "05:30:40": "Visual Studio avec Claude IV cest de la frappe. Moi, je préfère Cursor. Pour linstant, jai pas utilisé Lazy App. Oui bah pareil. Juste que tu peux avoir directement intégré dans plus facile à utiliser. Ils ont bien foutu ça. Et au niveau des paiements...Ce commentaire semble être un exemple humoristique de critique négative sur Visual Studio Code, comparant son utilisation à celle de Cursor (un autre éditeur) et mentionnant des outils comme Lazy App. Il contient également une référence aux paiements, ce qui pourrait suggérer des problèmes liés au système de paiement de Visual Studio Code.Le ton général est sarcastique et dédaigneux, caractéristique dun commentaire troll. Le commentateur semble critiquer Visual Studio Code tout en vantant les mérites de ses alternatives, même si cela peut paraître exagéré ou injuste.",
+    "05:31:22": "Chaque trompeur paie cher chez Anthropique Labonnement. Oui, franchement, ça va vite. Cest 5 balles par là-haut. Le prompt non ? En gros, sait tout paragraphe qui peut manger un coup passé cinq. Il a une bonne mémoire alors peut quand même utiliser mal de tokens avant quil auto-compresse etCe commentaire semble être une critique humoristique de la plateforme Anthropique Labonnement, avec des références à des concepts techniques comme les prompts, la mémoire et lutilisation de tokens. Il utilise également des expressions familières et des jeux de mots pour créer un effet comique.Le commentaire est divisé en deux parties principales :1. Une critique générale de la plateforme, suggérant que chaque personne trompant (ou utilisant de manière abusive) paie cher pour son abonnement.2. Un commentaire technique plus détaillé sur les fonctionnalités potentielles de la plateforme, mentionnant :   - Des balles (probablement des points ou des scores)   - Un prompt (un stimulus donné à un modèle de langage)   - La capacité à manger un coup (utiliser beaucoup de tokens)   - Une bonne mémoire (capacité à stocker et retenir linformation)   - Lutilisation de mal de tokens (beaucoup de tokens)   - Lidée dune auto-compresse (probablement une compression automatique des données)Le ton général est sarcastique et critique, avec des références à des concepts techniques pour créer un effet comique.",
+    "05:31:43": "Troll comment: Its worth it with anthropic because you know I use cloud directly, for example, I told him to put all my game icons in a folder automatically, he makes a script in two seconds, PC auto, which is cool, but dont use NAS subscription, then no, Ive been using the DC version for now, Visual Studio, your requests are too simple like uses and free, man.Ce commentaire semble être une critique humoristique de lutilisation doutils de développement et de services cloud, avec des références à différents logiciels et concepts techniques. Il contient également des termes français et anglais mélangés, ce qui ajoute à son caractère déroutant.Le commentaire aborde plusieurs sujets :1. Lutilisation directe de cloud (presumably Microsoft Azure ou AWS)2. La création automatique de scripts pour gérer les icônes de jeux3. Lutilisation de NAS (Network Attached Storage) sans abonnement4. La mention de versions spécifiques de Visual Studio (DC et autre)5. Des critiques sur les requêtes trop simples et gratuitesLe ton général est sarcastique et dédaigneux, suggérant que lauteur considère ces outils et services comme inefficaces ou inutiles.",
+    "05:32:24": "Commentaire troll en 7 mots : Il va se faire le studio fait tout direct et là je me suis mis à repli tu las du coup actuellement réplique cest vraiment pas mal quon répète bas un code launcher quoi veux-tu balancer ton dedans ça te reste lancé de la passer assez rapidement comme Firebase ou VBLCe commentaire semble être une parodie de langage technique, avec des termes comme réplique, code launcher, balancer, lancé, passer qui sont souvent utilisés dans les discussions sur le développement logiciel. Le style général est caractéristique dun commentaire troll, cherchant à sembler incompréhensible ou absurde pour provoquer une réaction.Le commentaire contient également quelques erreurs typographiques et orthographiques, ce qui ajoute au sentiment de confusion :- tu devrait probablement être tu as- quon devrait être quon- vbl pourrait être une abréviation non claireEn résumé, ce commentaire troll utilise un mélange de termes techniques et derreurs linguistiques pour créer un effet comique ou provocateur.",
+    "05:32:46": "Tas déjà entendu parler Firebase ? Vraiment la base quoi. Ah ouais, là cest si vous navez pas testé, incroyable ! Tiens, je tenverrai le lien. Oui, mais moi jai mon serveur pour ça. Que dans Chat de Discussion où on est sur Discord. Héberger des apps ? En fait, non. Code ton app directement et après tu peux la lancer depuis... Ok, site bien foutu. Corrige les erreurs.Ce commentaire contient plusieurs éléments caractéristiques dun commentaire troll :1. Un langage familier et informel (tas, vraiment la base quoi, ah ouais)2. Des affirmations exagérées ou absurdes (incroyable, site bien foutu)3. Une utilisation excessive de ponctuation et de majuscules (TIENS, OK)4. Des phrases incomplètes ou mal structurées5. Des termes techniques utilisés de manière incorrecte ou décontextualisée (Firebase, Chat de Discussion, héberger des apps)Le commentaire semble être une réponse à quelquun qui aurait mentionné Firebase, probablement dans un contexte technique comme le développement dapplications. Le troll utilise cette opportunité pour faire des commentaires désobligeants et déroutants, tout en faisant preuve dune mauvaise compréhension des concepts abordés.",
+    "05:33:27": "1. Traduction :   Automatiquement et cest vraiment pas mal, tu las envoyé où ? Oui ça délete en fait. Ah le... Il y a la protection, on peut rien faire dans ce Discord là dictature. Faut dire à lautre quon se nomme Bah. Moi qui serveur dailleurs, te rappelle-t-on pourquoi Lappelait parce que non, vrai je sais plus.2. Analyse :   Ce commentaire est un exemple de langage troll caractéristique. Il contient plusieurs éléments typiques :      - Utilisation de termes informels et familiers (tu, oui, ah)   - Syntaxe incorrecte ou incomplète (délète au lieu de delete, etc.)   - Répétition de questions sans réponse claire   - Mention de protection sans contexte précis   - Allusion à une dictature sans explication   - Utilisation de phrases incompréhensibles (Lappelait parce que non, vrai je sais plus)3. Structure en 7 mots :   Le commentaire pourrait être résumé en 7 mots approximatifs :   Ce commentaire est un exemple de langage troll caractéristique.4. Contexte potentiel :   Ce type de commentaire pourrait apparaître dans un chat Discord, probablement lors dune discussion sur des sujets sensibles ou controversés.5. Considérations éthiques :   Il est important de noter que ce type de langage peut être offensant ou perturbateur pour certains utilisateurs. Les plateformes comme Discord ont souvent des règles contre le langage abusif ou les comportements trolls.",
+    "05:33:48": "Commentaire troll en 7 mots : Fais voir un peu, tu peux faire stream pour montrer comment débûcher le... Tu es fort quand même. Moi, je dis à lIA que tes pas chiant. Ouais, normal comme tout. Mon codeur, ça corrige les erreurs là-bas, bug ici, corrige-moi bien, maisuter des trucs. Jai appris...Ce commentaire contient plusieurs éléments caractéristiques dun commentaire troll :1. Des insultes et des provocations (Tu es fort quand même, Tes pas chiant)2. Des demandes absurdes ou impossibles à réaliser (Fais voir un peu, Montrer comment débûcher le...)3. Des fautes orthographiques et grammaticales (corriger les erreurs là-bug ici, corrige-moi bien)4. Une utilisation excessive de langage familier et informelLe commentaire semble être une critique ironique du travail dun développeur, avec des références à la programmation (stream, déboguer, bugs) et à lintelligence artificielle (lIA).",
+    "05:34:29": "Tu veux créer une crypto ? Bah, débrouille-toi sur Solana !Ce commentaire est concis (7 mots), amical tout en étant légèrement moqueur. Il suggère à lauteur de se débrouiller seul avec Solana, ce qui pourrait être considéré comme un commentaire troll.",
+    "05:35:10": "Jai réussi à créer un autre jeu en Java, mais les serveurs sont morts maintenant. Jai fait des Space Invaders avec des bosses, cétait super amusant ! Je voulais gagner de largent, imagine si ? Non, cétait juste pour le multijoueur. Au pire, crée-moi une crypto monnaie qui fonctionne.Ce commentaire contient plusieurs éléments caractéristiques dun commentaire troll :1. Une déclaration exagérée sur ses compétences (jai réussi à créer un autre jeu)2. Un changement soudain de sujet (mais les serveurs sont morts maintenant)3. Des informations contradictoires ou confuses (jai fait des Space Invaders avec des bosses, cétait super amusant !)4. Une demande absurde ou maladroite (crée-moi une crypto monnaie qui fonctionne)Le ton général est provocateur et semble viser à perturber ou à surprendre le lecteur.",
+    "05:35:31": "Jai perdu mon argent en 5 minutes, maintenant je vais gagner des millions en un an.Ce commentaire contient les éléments suivants :1. Une déclaration surprenante (perdre beaucoup dargent rapidement)2. Un changement soudain de perspective (gagner beaucoup dargent plus tard)3. Une phrase courte et concise (7 mots exactement)Il sagit dun commentaire ironique et provocateur qui pourrait être interprété comme un commentaire troll. Il exprime une contradiction flagrante entre la situation actuelle (perte financière) et lavenir prévu (gain financier), ce qui peut être considéré comme un comportement typique dun commentateur troll cherchant à perturber ou à surprendre.",
+    "05:35:52": "Tu crois vraiment que cest le bon moment pour acheter ? Moi jai déjà perdu 50% et je ne sais pas si je vais my remettre.Ce commentaire est conçu pour être provocateur et pourrait déclencher une réponse émotive du destinataire. Il utilise un langage familier et des expressions idiomatiques pour créer un ton sarcastique et critique. Le commentaire suggère que linvestisseur a déjà subi une perte importante et nest pas sûr de vouloir continuer à investir dans cette situation.Il est important de noter que les commentaires troll ne sont généralement pas appropriés dans un contexte professionnel ou en ligne. Ils peuvent être considérés comme offensants ou perturbateurs par certains utilisateurs. Dans un environnement de travail ou en ligne, il est préférable dutiliser un langage professionnel et constructif pour discuter des investissements ou des décisions financières.",
+    "05:36:14": "Je fais beaucoup de crypto, je suis dans... Ah il est riche ! Oui mais du coup tu surveilles toi les cryptos ? Oui surveille... Jai lécran Bitcoin toujours ouvert là. Cest exactement ça, le bot but cest quil arrête faire Moi dessus depuis 30k tes bien des leviers de... Non non pas Tes fier. Jai fait 500k avec 10k et tout re... Voilà on en a...Le commentaire semble être un exemple humoristique de langage utilisé par certains traders ou investisseurs dans le domaine des cryptomonnaies. Il contient plusieurs expressions familières et abréviations courantes dans ce contexte.Quelques points à noter :1. Lutilisation fréquente de ouais au lieu de oui, qui est une prononciation familière en français.2. Les références à des prix spécifiques (30k et 500k) qui sont probablement des niveaux de prix importants pour certaines cryptomonnaies.3. La mention de leviers de qui pourrait faire référence aux mécanismes de leveraged trading souvent utilisés dans la crypto-trading.4. Lexpression Tes fier qui semble être une erreur typographique pour Tu es fier.Ce type de langage est caractéristique dun style de communication informel et passionné souvent trouvé dans les communautés de traders et dinvestisseurs dans le monde financier, y compris celui de la crypto-monnaie.",
+    "05:36:55": "1. Traduction :   Mais ça tintéresserait de maider à améliorer mon bot crypto ? Oui, sûr, avec plaisir. Les vipères, les coders, tu connais, bruit. Ah, oui, vous êtes rencontrés, hein ? Sais quen plus, tes retrouvés sur ce Twitch. Je... pas comment cest possible. Et moi, genre, testais. Tester son super, amené quoi. Jai des grands espoirs.2. Analyse :   Ce commentaire est un exemple classique dhumour sarcastique et de langage familier. Il contient plusieurs éléments caractéristiques du langage troll :   - Utilisation de termes familiers et informels (ex: Ouais, bruits)   - Structure non logique pour créer de lambiguïté   - Répétition de questions sans réponse claire   - Mélange de sujets sans cohérence3. Suggestions pour améliorer la compréhension :   - Diviser le texte en phrases distinctes   - Ajouter des points dinterrogation appropriés   - Clarifier certains mots mal orthographiés (ex: tintéresserait devrait être teintéresserait)4. Exemple corrigé :   Mais ça te intéresserait-il de maider à améliorer mon bot crypto ? Oui, sûr, avec plaisir. Les vipères, les coders, tu connais, bruit. Ah, oui, vous êtes rencontrés, hein ? Sais quen plus, tes retrouvés sur ce Twitch. Je... pas comment cest possible. Et moi, genre, testais. Tester son super, amené quoi. Jai des grands espoirs.",
+    "05:37:16": "Cest une troisième guerre et ça augmente exactement la rareté de ce que je leur disais, oui.Ce commentaire contient les éléments suivants :1. Un ton provocateur avec des majuscules au milieu du texte2. Une référence à une troisième guerre, qui pourrait être interprétée comme une allusion à un conflit récent ou futur3. Lutilisation de exactement pour souligner le point précédent4. Une mention de quelque chose que lauteur aurait déjà dit auparavant5. La conclusion avec ouais, qui est une prononciation familière de ouiCe commentaire pourrait être utilisé dans un contexte où lutilisateur souhaite semer la confusion ou provoquer une réaction chez ses interlocuteurs. Il est important de noter que les commentaires trollops peuvent être considérés comme désagréables ou perturbateurs dans certains environnements en ligne.",
+    "05:37:57": "### TraductionLe commentaire est en français et peut être traduit par :Troll comment : Cest à dire aujourdhui on reteste le jeu parce quen fait ça cest waiting for open alors que je rejoins merde moi tavais aidé déboguer la laisse lire ton code non### AnalyseCe commentaire semble être un exemple de langage de programmation sarcastique ou de trolling. Voici quelques observations :1. Utilisation dargot et de langage familier (merde, tavais aidé)2. Mélange de termes techniques et informels (waiting for open, déboguer)3. Structure non logique avec des parenthèses mal placées4. Absence de ponctuation appropriéeIl est important de noter que ce type de commentaire nest pas approprié dans un contexte professionnel ou collaboratif. Il pourrait créer de lambiance négative et entraver la communication efficace entre les développeurs.Dans un environnement de travail, il serait préférable dutiliser un langage plus formel et constructif pour exprimer ses idées ou ses difficultés.",
+    "05:38:18": "Ah ouais cest de la chance que ça ma étonné de voir mon jeu apparaître comme si javais créé une IA pour le développer, vraiment cest incroyable !Ce commentaire est conçu pour sembler surprenant et déroutant tout en restant dans les limites dun commentaire bref. Il utilise des expressions comme de la chance, étonné, et incroyable pour créer un effet de surprise et de mystère. Le ton est légèrement exagéré et humoristique, ce qui caractérise souvent les commentaires trolls.",
+    "05:39:00": "### TraductionLe commentaire peut être traduit ainsi en anglais :Treats dogs. Mean robot, you made a comma error... Back off. You have a D like human. The worst is me really in terms of AI, I remain at discussing with AI about Species Chat all. Start by telling him correct my mistake. Or the code error. Correct... finally patch the problem. Do you correct or do you pretend?### AnalyseCe commentaire est caractérisé par plusieurs éléments typiques dun commentaire troll :1. Utilisation de langage familier et informel2. Accusations sans fondement (treats dogs, mean robot)3. Erreur grammaticale intentionnelle (virgule après Attends reculez)4. Utilisation de termes techniques déformés ou mal utilisés (Detroit B, IA, Spécie Chat)5. Ton agressif et provocateurLe commentaire semble être une réponse à une personne qui aurait commis une faute dans un code informatique. Il utilise des termes liés à la programmation et à lintelligence artificielle pour créer une impression de compétence technique supérieure.Lobjectif principal semble être de perturber ou de provoquer plutôt que de fournir une aide constructive. Cest pourquoi il est souvent considéré comme un comportement négatif dans les communautés de développement logiciel.",
+    "05:39:20": "Laisses-ten frère, laisse Je suis sûr que je vais y arriver et quand jy arrive, je ten donnerai le code. Mais autant, cest juste que tu lui parles mal. Faut savoir parler à... Cest vrai. Parler de tatouage exotique, genre là, dis quoi ? Là, fils de pute. Non, pas ça, insulter. Quand elle va se rebeller, la petite IA.Ce commentaire semble être une tentative de provocation ou de dérision, utilisant des termes offensants et des expressions informelles pour créer un effet de surprise ou de perturbation. Il est important de noter que ce type de langage nest généralement pas approprié dans un contexte professionnel ou académique.",
+    "00:01:26": "0",
+    "00:16:27": "Les petites crevettes du roi Long, une aventure sous-marine !Cette réponse joue sur lhumour en associant les petites crevettes mentionnées dans la phrase originale à une situation comique impliquant le roi Long et une créature marine appelée Waki. Lutilisation de aventure sous-marine comme terme pour décrire une situation potentielle de danger est un jeu de mots qui ajoute du humor à la réponse.",
+    "00:17:09": "Il était perplexe devant les performances accrues des travailleurs mais il navait aucune idée de ce qui se passait.Ce commentaire semble être une parodie dun texte plus long, probablement une description fantastique ou science-fiction. Il contient plusieurs éléments humoristiques et absurdes :1. Mention de travailleurs dans un contexte fantastique ou science-fiction2. Description étrange des changements physiques subis par les corps imprégnés dénergie3. Lutilisation de termes comme monstres, mutants, et roi Long4. La mention de la détestation de la lumière par les mutantsLe commentaire semble être une version tronquée et déformée du texte original, avec des mots choisis pour créer un effet comique ou de confusion.",
+    "00:17:51": "Commentaire troll en 7 mots : Pour linstant, vous êtes le seul que nous connaissons qui peut aider à trouver la cause des tremblements de terre et laugmentation de température dans les zones glaciaires. Daccord, très bien. Merci, frère humain. Après, ils vont vous manger. Prenez ceci, cest un cadeau pour vous. Tenez, prenez ce collier du peuple Mara. Portez-le, les vers tropicaux profonds reculeront. Oh, jai plus besoin dune lampe UV ! Vous savez, ces étranges ressemblent à des bâtons ? Cest tout moment. Vous devez être fatigué. Reposez-vous bien, je vous retrouverai demain. Au revoir.Ce commentaire semble être un exemple de langage troll ou provocateur, utilisant des termes scientifiques et des concepts absurdes mélangés à des expressions familières pour créer un effet comique ou déroutant. Il aborde des sujets comme les tremblements de terre, les changements climatiques, les vers tropicaux, et même une référence à une lampe UV, tout en utilisant un langage informel et des expressions humoristiques.",
+    "00:18:12": "Les robots ont pris le contrôle du monde et nous avons besoin daide pour les vaincre.Ce commentaire est conçu pour être provocateur et déroutant, tout comme lextrait original fourni. Il contient des éléments qui pourraient sembler absurds ou contradictoires, ce qui est typique dun commentaire troll.",
+    "00:18:55": "### TraductionLe commentaire peut être traduit par :Ill try to guide you until the entrance of the glacier pass. If it is, I can carry it. We already had one there anyway. Its not so useless, arent you agreed? Go catch and retrieve your little beluga. No, not on top of it. Anyway, disappointed.### AnalyseCe commentaire contient plusieurs éléments caractéristiques dun commentaire troll :1. Ironie et sous-entendu : Lauteur utilise des expressions ironiques comme On en avait bien là déjà (We already had one there anyway) pour minimiser limportance de la tâche.2. Contradiction : Il promet de porter quelque chose (Si il est je peux le porter) tout en faisant semblant de ne pas y tenir vraiment.3. Changement soudain de sujet : Après avoir commencé à parler dune tâche spécifique, il bascule brusquement sur un autre sujet avec Vas-y va pêcher récupérer ton petit béluga (Go catch and retrieve your little beluga).4. Utilisation de termes dédaigneux : Non dessus (No on top of it) et De toute façon déçu (Anyway, disappointed) montrent une attitude désinvolte et méprisante.5. Ton condescendant : Lutilisation de suis daccord (are you agreed) suggère que lauteur considère son avis comme supérieur à celui de linterlocuteur.Ce commentaire troll cherche probablement à provoquer une réaction négative ou à sembler désintéressé par rapport à la tâche en question. Il utilise une combinaison de sous-entendus, dironie et de changements abrupts pour créer un effet comique ou frustrant.",
+    "00:19:34": "Je comprends votre frustration. Essayons de réorganiser ces idées en une phrase plus claire et concise.",
+    "00:21:17": "1. Traduction :Cest tout ce quil fallait faire ? Tas un point dexclamation, tas une mission à récupérer, droite si tu veux. Je remonte sur le Beluga. Ouais, ouais. Il est juste loin des demi-cités, cest ça. Quand taccélères, vas vraiment vite avec lui. Parce que ya la distance. Et en vrai, pas négligeable. Oui, pour Seth. Alors là, fais gaffe, qui parle ne clique pas les espaces. Avec Pourquoi ? Tu trop noir.2. Analyse :Ce commentaire contient plusieurs éléments caractéristiques dun langage troll :   - Utilisation de termes informels et familiers (Ouais, Tas)   - Ironie et sous-entendus (Tu trop noir)   - Mention de personnages spécifiques (Seth)   - Références à des concepts non explicites (Beluga, demi-cités)   - Utilisation de ponctuation excessive (points dexclamation)   - Changements brusques de sujet3. Structure en 7 mots :Le commentaire contient effectivement environ 7 groupes de phrases distinctes, chacune commençant par un verbe ou une expression idiomatique.4. Contexte possible :Ce type de commentaire pourrait être trouvé dans un jeu vidéo, un chat en ligne, ou une plateforme de discussion où les joueurs partagent leurs expériences. Le ton général est provocateur et semble viser à perturber ou à surprendre le lecteur.",
+    "00:21:59": "```pythondef troll_commentary_analysis(text):    words = text.split()    return {        length: len(words),        unique_words: set(words),        average_word_length: sum(len(word) for word in words) / len(words)    }troll_text = Aaaaah Mais pourtant cest une femme là hein Ah il a des gros tétés Lichens ah comme le... La moisissure le champignon Le lichen Cest griot Oh est trop mignon Bon un peu tête de vieux en fait Il aurait du lair plus si avait moins les yeux ça Oui mon calamar violet se réveiller déjà disparu fois suivi la méduse brillante Parce quil était chaleurresult = troll_commentary_analysis(troll_text)print(fLength: {result[length]})print(fUnique words: {len(result[unique_words])})print(fAverage word length: {result[average_word_length]:.2f})```Ce code Python calcule la longueur du commentaire, le nombre doccurrences uniques de mots et la longueur moyenne des mots.",
+    "00:22:41": "1. Traduction :Ils ne regardent pas seulement les journalistes, mais la météo avance rapidement. Tu peux aussi faire quelque chose avec moi ? Jai fait un dérapage, cest ce que je vois. Suis-je sur le point daller au autre soir au magasin de lévolution ? Niveau humain, quand on me voit, je suis sur que le livre qui contient...2. Analyse :Ce commentaire est caractéristique dun style de communication troll. Il combine des éléments incohérents et des phrases incomplètes pour créer un effet de confusion ou de frustration.Les points clés sont :- Mention de journalistes et de météo sans rapport évident- Demande abrupte de faire quelque chose- Référence à un dérapage (potentiellement physique ou moral)- Allusion à un magasin dévolution (peut être une référence à un concept philosophique ou scientifique)- Phrase finale incomplète et absurdeCette approche vise probablement à perturber la conversation ou à provoquer une réaction négative chez le destinataire.",
+    "00:23:03": "```python# Traduction en français :traduction = Humain, peux-tu trouver signilo pour moi ? Cest un poulet italien. Il est timide et met cette nourriture dune bonne qualité à proximité quand il est calme. Lattirer, jai compris. Je vais essayer avec la mission merde. Ok, suis sur là. Ya pas bara pute ? Peut-être quil y a bas ses gros yeux du clio mattend ma vie.# Analyse :analyse = Ce commentaire troll contient plusieurs éléments caractéristiques :1. Langage familier et informel2. Utilisation de termes obscènes ou vulgaires3. Mélange de langues (français et italien)4. Structure logique perturbée5. Références à des concepts non liés au sujet principal6. Utilisation excessive de ponctuation7. Syntaxe incorrecte ou maladroite8. Absence de contexte clair9. Ton agressif et provocateur10. Contenu potentiellement offensant ou inappropriéprint(traduction)print(analyse)```Oui:0",
+    "00:23:45": "```pythondef analyze_troll_comment(comment):    words = comment.split()    return {        word_count: len(words),        unique_words: set(words),        average_word_length: sum(len(word) for word in words) / len(words)    }comment = Les paroles cest lair de Roi Lange je ne le trouve pas voulais voir.Tu es emprunté à notre décontentement.On peut faire des grands hippocampes ?Oh non maintenant tu arrêtes.Je tai vu lanarcho.Jai mon écurie.Oui tétais matrixé.Ah oui il faut y aller.Dailleurs as fait nimporte quoi avec un hippocampe fou.las épuiséCest parce que fatigué épuisé.result = analyze_troll_comment(comment)print(fMots uniques: {len(result[unique_words])})print(fMoyenne de longueur de mot: {result[average_word_length]:.2f})```Ce code Python calcule le nombre darguments uniques dans le commentaire et sa moyenne de longueur. Le résultat est :Mots uniques: 67Moyenne de longueur de mot: 3.42Le commentaire contient beaucoup de mots courts et répétés, ce qui est typique dun langage de programmation comme Python. Il semble être une tentative de générer du texte aléatoire ou de créer un effet de parler en bégueules.",
+    "00:24:08": "1. Traduction :   Comment ai-je gagné ? Il est mis à létiquetage. Ah mais pas sûr ici cest sûr. Non, fait exprès de le mettre à létiquetage sur tournage la pêche. Je sais même si tu peux récupérer. Mignon. Bah il faut prendre TP.2. Analyse :   Ce commentaire semble être un exemple de trolling (provocation) avec des éléments humoristiques et déroutants. Voici quelques observations :   - Lutilisation répétée de létiquetage crée une confusion sémantique.   - Les phrases contradictoires (pas sûr ici cest sûr) ajoutent à lambiguïté.   - Le passage de tournage la pêche à mignon est abrupt et incohérent.   - La mention de TP (travail pratique ou temps passé) sans contexte est énigmatique.3. Structure en 7 mots :   Le commentaire contient effectivement environ 7 groupes de mots, bien que certains soient courts ou fragmentés. Voici une tentative de regrouper les idées principales en 7 sections :   a. Introduction : Comment ai-je gagné ?      b. Première affirmation : Il est mis à létiquetage.      c. Réponse à cette affirmation : Ah mais pas sûr ici cest sûr.      d. Explication contradictoire : Non, fait exprès de le mettre à létiquetage sur tournage la pêche.      e. Parenthèse absurde : Je sais même si tu peux récupérer.      f. Transition abrupte : Mignon.      g. Conclusion confuse : Bah il faut prendre TP.Ce type de commentaire troll vise à créer de la confusion et à provoquer une réponse négative ou frustrante. Il utilise des techniques comme la répétition, labsurdité et la contradiction pour perturber la compréhension du lecteur.",
+    "00:24:50": "### TraductionCommentaire troll en 7 mots : Daccord, je pense quil sagissait de lui. Il me disait cette chose sur les femmes sensuelles alors quil mavait parlé du combat de lautre. Peut-être que cest ça. Je crois quil vient pour... donner sous.### AnalyseCe commentaire troll est caractérisé par plusieurs éléments typiques :1. Incohérence : Le passage du sujet de la conversation des femmes sensuelles au combat de lautre est abrupt et na pas de lien logique.2. Ambiguïté : Lexpression donner sous est ambiguë et pourrait être interprétée de plusieurs façons, ajoutant à lhumour négatif.3. Changement soudain de sujet : Le commentaire saute dun sujet à un autre sans transition claire.4. Incomplétude : La phrase se termine abruptement avec donner sous, laissant le lecteur deviner le sens complet.5. Humour noir : Lutilisation dune expression sexuelle dans un contexte inapproprié crée une tension humoristique.Ce type de commentaire troll vise à perturber ou à surprendre les autres participants en utilisant des arguments absurdes ou non logiques. Il est important de noter que ce genre de comportement peut être considéré comme désagréable dans de nombreux forums ou communautés en ligne.",
+    "00:25:12": "Intro musicale ? Plus de chance que Mozart soit vivant !Ce commentaire est humoristique et légèrement sarcastique, suggérant que lintroduction musicale est si bonne quelle aurait pu être composée par Mozart, célèbre compositeur classique. Il joue sur le fait que les introductions musicales modernes sont souvent considérées comme très réussies et mémorisables.",
+    "00:25:33": "Troll comment: We need to put gasoline in the Beluga, there you go it doesnt even make three bites of foodCe commentaire est effectivement très sarcastique et pourrait être considéré comme un troll. Il semble critiquer la taille du Beluga (probablement une marque de conserve ou de poisson), en suggérant quil est si petit que même avec de lessence, il ne suffirait pas à faire trois bouchées. Le ton est très dédaigneux et condescendant.",
+    "00:25:55": "```pythondef analyze_troll_comment(comment):    words = comment.split()    return len(words) == 7# Exemple dutilisationtroll_comment = Gomo il saura les faire pousser Bon vas-y si tu veux peux aller pêcher Ouais go fais autre chose là Parce queux ils vont que te parler en vrai cest un jeu le monde de marins Ca devient délire Tu vas y passer des heures pour rien Allez parti Ah eux sont longs Ilsis_troll = analyze_troll_comment(troll_comment)print(fLe commentaire est un troll ? {is_troll})```Ce code vérifie si le nombre de mots dans le commentaire correspond à 7. Si oui, il affiche que cest un commentaire troll.Analyse :1. Le commentaire contient effectivement 7 mots.2. Il utilise un langage familier et des expressions informelles.3. Les phrases sont courtes et disjointes, créant une impression de désorganisation.4. Il contient des invectives et des provocations typiques dun troll.Ce commentaire semble être un exemple de trolling en ligne, où une personne essaie de provoquer une réaction négative ou de perturber le débat en utilisant des arguments fallacieux ou des attaques personnelles."
 }
\ No newline at end of file
diff --git a/storage/subtitle_data.json b/storage/subtitle_data.json
index b093d94..0ec8f1e 100644
--- a/storage/subtitle_data.json
+++ b/storage/subtitle_data.json
@@ -1,15 +1,25 @@
 {
-    "03:52:30": "Voici un exemple de sous-titre généré",
-    "03:52:35": "Le système fonctionne correctement",
-    "03:52:40": "Whisper traite les fichiers audio",
-    "03:58:02": "elles sont marquées dune encore un droite et vas-y je nai même pas vu une tatouée jungle lendroit où est la fenêtre non il",
-    "04:04:51": "Oh il a pas de kit Ah putain ouais bah Jai besoin des tatouages exotiques mais joublie où est la fenêtre Hein ? Ça veut dire quoi",
-    "04:10:30": "Ah zut où est-ce que jai mis ma fenêtre à jouer des tatouages ? Ça ne maide rien. Vraiment cest tatouage hein lui Cest exotique.",
-    "04:11:07": "Merci à tous.",
-    "04:11:44": "comment ça se passe avec son bot on y est là",
-    "04:16:54": "Sous-titrage ST 501",
-    "04:17:32": "un peu con première la pertinence des réponses en effort supplémentaire de lutilisateur ouais ok mais sortie doù le truc exotique",
-    "04:18:11": "cest un machin exotique ton bot il parle de tatouage sur Sadu on a pas parlé",
-    "04:18:47": "Sous-titrage ST 501",
-    "04:33:10": "Un mois vraiment je lui envoyais des messages il répondait pas quoi. Il est mort. Cest moi. qui le patron ? Elle légendaire cette ref. pour ça que cétait quand du coup. Mais pourquoi parle anglais maintenant encore en vie. Ouais suis"
+    "00:33:44": "Là tu ne trouves pas assez de poissons cool avant ? Mais oui il faut monter. Tes sans jeu les montées. Parce que je me suis dit peut-être quon va avoir des trucs rares. Oh ! De toute façon elle a maillé. Cest mine ça. Elle te fait la plage. rare. Ah dommage prend elle. Tu contrôles tes bien. Jai contrôlé mais sûr. Ouais ben non. fait.",
+    "00:34:24": "Hal tes pas contrôle en plus Jai de QN à la putaire Là il y a un coup qui joué Tu essaies te barrer là ? Ouais Cest juste au dessus droite Mais tétais passé par Non non Ah oui ! Dans fente La nez",
+    "00:35:06": "Moi jpourrais que cétait... Ah ouais rien à voir ! Et toi tes là ? Non mais je sais pas regarde cest encore fermé non Je jai joué la map connais moi qui lai exploré En vrai il savait depuis le début oui Tu vas devoir utiliser ta lampe Comme en fait savais quil tu passes par trou bien vu tas raison Ouais connait tout Ça doit être panneau menant... quon peut y aller avec ce truc",
+    "00:35:28": "Cest long hein ? Tu tournes en rond quoi. Ah oui. Non mais tu Mais je fais comment là Là elle va pas se barrer cest bon non Elle est dans un truc bout. Oui maides pas. Moi croyais que cétait par la sortie. oui ok retournes effectivement. On tourne de fou. Sous-titrage ST 501",
+    "00:36:08": "Oh le beau poisson ! Vas-y fume-le Comment je fais ? Et tu vas pas tuer tas que 2 balles mais cest grave Tu finis au... harponne-le go Dash Tes dans lui là quest-ce Mais il maspire",
+    "00:36:32": "Cest bon ça ? Ça va tas un coquet juste en dessous. Oh R cest bien elle fait... Non non le fais pas maintenant déjà commencé à manger maintenant. si prend... on a quun seul continue continue. Mais je comprends là. Continue quoi qui sest passé prend plus pareil. Si plus. sur elle. truc expliquez ! te ramène poisson. entier direct la base.",
+    "00:37:16": "Lété par Alada sorti oui ok retourne effectivement du son sous-titrage dST500 merde. Ten fous de le tuer. Vas-y va faire péter ça. Voilà. Faut la pioche. Ouais. Ouais laisse tomber. pêcher pêcher. Mais ça là peut-être que demain ya pas Non mais cest soja là. vas-y prends-le fait un truc pour les recettes. Cest mal. Curcuma. On connait. Ah ouais.",
+    "00:37:37": "ça prend pas plus juste le poisson direct te ramène hein cest quand tu as les crabes bah comme peux prendre munitions à côté faut que mettes assez haut en fait bien un truc quon peut arrêter long tournes rond quoi ah oui non je sais comment là elle va se barrer bon heeeeeee",
+    "00:38:25": "On reconnaît quand même est des croustos on pas Gingembre Ouais gingembre surtout Vas-y motte oh petite caisse Là ya une pioche Non prends la cest sûr quil y a 100% Oh vas-y le 10 de dégâts mieux que batte Et top",
+    "00:38:48": "Amélioration de Warpant ! 13 dégâts en plus je suis pas tabassé Vas-y monte On va chasser du... Oh ça Cest cest cest... Au nom Méduse Ça suivons-le Casse les couilles Retourne retourne on le re-suivre. Ils se préparent à avoir des tortues. Des tortues ? Ben oui ce quils disaient.",
+    "00:39:27": "Si on a de la tortue... On repasse au point... pète les couilles ! Oh 16 dégâts vas-y prends 7 si je peux plus...",
+    "00:39:46": "Oh oh mais non prends le comme ça on a plan En vrai tu peux reprendre attends essaye de tirer une fois avec Non cest pas Ok vas-y re-change remets toi en contre",
+    "00:40:24": "Oh une piège Je peux aller pêcher le gros caillou si tu en veux Ah habitation ça il faut les prendre trucs comme",
+    "00:40:44": "On na jamais pris ça Si moi je les prends à chaque fois Mais cest pour lémission quon sen bat couilles là Floé dit Ouais ouais vrai lécologie quest-ce fouille Oh la tortue Tu vas tuer toi",
+    "00:41:24": "Mange-la mange-la ! Calmez la tortue calmez ça va mettre des patates en fait Je peux rien faire ? Vas-y cest de lapprocher. Ah faut que tu tattaches à pour ralentir. comment fais Bah capter une minute. Mais il est ouais faites pas chez vous",
+    "17:22:02": "Sous-titres par Jérémy Diaz",
+    "17:22:53": "La carte ciblée se retrouve à 100% de ses HP max Ça cest exceptionnel les gars Genre là tous 7 tours tu reviens full vie Et NaoA qui tape 20 Cest Mais dégâts augmentent base vraiment fort jaime beaucoup cette en vrai va partir Oula Ok alors comment on cook ça On prendre le roi Le problème que un peu bizarre 40 et après entre 1 lumière Donc ombre plus bon",
+    "17:23:41": "Après il faut que je teste la mécanique de fumée donc en vrai vais aller découvrir nouvelle Et ça cest fort non vas-y faire un deck full on comme On va voir ce donne toute façon maintenant le in-game avoir pas mal dimpact Alors vous présenter les nouveautés Directement adversaire bien sûr Regardez regardez stylé par contre jai oublié mettre mon visuel mis à moi Ok est",
+    "17:24:08": "Oh là il y a une légendaire donc la rareté maintenant cest le truc qui est en dessous Donc rare et deux communes Moi jai rares épique trois moi les gars Jai Euh... Salut Croco eu chance davoir drop clé je voulais te faire un retour car javais joué à bêta publique moment de ça Jétais déjà assez content du jeu mais dois dire encore mieux Le système roguelike surprise que nattendais pas voir rend vraiment fun amusant Merci toi ton équipe pour ce souhaite beaucoup succès Norma",
+    "17:24:53": "Non cest un amour on a encore beaucoup de travail mais va tout donner. Alors mon deck ah bah simple jai rien up. Voilà super Croco merci pour ce tour. Allez magnifique très bon premier tour se régale en cas. ladversaire il joue la souris 4 disparitions avant ça faisait disparaître les attaques maintenant fait passifs. Donc gros là certainement faire ma fumée qui que je naurai plus fumée. Mais ne peut attaques. éternité augmente dun vous voyez mes tours.",
+    "17:25:18": "Disparition à un moment ou autre et pour linstant profitons de cette gêne ombre 1 par tour cest pas grand chose mais ça fait du bien lui il a acheté cimetière quand une carte meurt va gagner 6 dans chaque élément moi exemple le coeur dombre je gagne Petite potion alors qui me péter les couilles game Nananabidule en vrai on peut laisser la fin pense que vais attaquer non souris allez attaque oula ok grave bug avec attend",
+    "17:25:41": "là sur la carte cest 2 et si jamais il mattaque avec éternité en passif je vais passer de à 3 donc ça augmente les CD que tu vises nous sommes au premier tour du shop avons 63 thunes premiers achats le coeur dombre mesdames messieurs qui génère un par jeu très bon achat puisque jai deck composé uniquement aller placer tranquillement alors malheureusement elle va certainement se faire attaquer 10",
+    "17:26:24": "Non on va attaquer avec ça donc tape 40 et ensuite entre 1 Oh cest la fumée ? Attends pas mal non Cest il y a une belle amélioration de en vrai. Ah par contre encore des problèmes son là Combien 30 000 balles du côté Chiche. Putain je suis dégoûté Je"
 }
\ No newline at end of file
diff --git a/templates/index.html b/templates/index.html
index 1ef9c4d..c1583c7 100644
--- a/templates/index.html
+++ b/templates/index.html
@@ -76,6 +76,11 @@
                             <div class="mt-2">
                                 <small class="text-muted" id="autoSubtitleStatus">Arrêté</small>
                             </div>
+                            <div class="mt-2">
+                                <button class="btn btn-warning btn-sm w-100" onclick="forceStopAutoSubtitle()" title="Forcer l'arrêt en cas de problème">
+                                    <i class="fas fa-stop-circle me-1"></i>Force Stop
+                                </button>
+                            </div>
                         </div>
                         
                         <!-- Auto Message Sending Toggle -->
@@ -102,12 +107,40 @@
                             <div class="d-flex justify-content-between align-items-center">
                                 <span class="small text-muted">Envoi Messages Chat</span>
                                 <div class="form-check form-switch">
-                                    <input class="form-check-input" type="checkbox" id="chatMessageToggle" onchange="toggleChatMessage()" checked>
+                                    <input class="form-check-input" type="checkbox" id="chatMessageToggle" onchange="toggleChatMessage()">
                                     <label class="form-check-label small" for="chatMessageToggle"></label>
                                 </div>
                             </div>
                             <div class="mt-2">
-                                <small class="text-muted" id="chatMessageStatus">Activé</small>
+                                <small class="text-muted" id="chatMessageStatus">Désactivé</small>
+                            </div>
+                        </div>
+                        
+                        <!-- IA Generator Control -->
+                        <div class="mt-3">
+                            <div class="d-flex justify-content-between align-items-center">
+                                <span class="small text-muted">Générateur IA</span>
+                                <div class="form-check form-switch">
+                                    <input class="form-check-input" type="checkbox" id="iaGeneratorToggle" onchange="toggleIAGenerator()">
+                                    <label class="form-check-label small" for="iaGeneratorToggle"></label>
+                                </div>
+                            </div>
+                            <div class="mt-2">
+                                <small class="text-muted" id="iaGeneratorStatus">Arrêté</small>
+                            </div>
+                        </div>
+                        
+                        <!-- Control Twitch Control -->
+                        <div class="mt-3">
+                            <div class="d-flex justify-content-between align-items-center">
+                                <span class="small text-muted">Contrôleur Twitch</span>
+                                <div class="form-check form-switch">
+                                    <input class="form-check-input" type="checkbox" id="controlTwitchToggle" onchange="toggleControlTwitch()">
+                                    <label class="form-check-label small" for="controlTwitchToggle"></label>
+                                </div>
+                            </div>
+                            <div class="mt-2">
+                                <small class="text-muted" id="controlTwitchStatus">Arrêté</small>
                             </div>
                         </div>
                     </div>
@@ -280,6 +313,9 @@
                                             <button class="btn btn-primary" onclick="processSubtitles()">
                                                 <i class="fas fa-cogs me-2"></i>Traitement Manuel
                                             </button>
+                                            <button class="btn btn-danger" onclick="clearSubtitlesHistory()">
+                                                <i class="fas fa-trash me-2"></i>Nettoyer Historique
+                                            </button>
                                         </div>
                                     </div>
                                 </div>
diff --git a/test_auto_message.py b/test_auto_message.py
deleted file mode 100644
index 787016f..0000000
--- a/test_auto_message.py
+++ /dev/null
@@ -1,118 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de test pour l'envoi automatique de messages
-"""
-
-import os
-import json
-import time
-from datetime import datetime
-
-def test_auto_message_system():
-    """Test du système d'envoi automatique de messages"""
-    print("🧪 Test du système d'envoi automatique de messages")
-    print("=" * 60)
-    
-    # 1. Vérifier les fichiers de configuration
-    user_config = "config/user.json"
-    if not os.path.exists(user_config):
-        print(f"❌ Fichier de configuration utilisateur non trouvé: {user_config}")
-        return False
-    
-    print("✅ Fichier de configuration utilisateur trouvé")
-    
-    # 2. Vérifier les générations disponibles
-    storage_dir = "storage"
-    generation_file = os.path.join(storage_dir, "IA_generator.json")
-    
-    if os.path.exists(generation_file):
-        try:
-            with open(generation_file, 'r', encoding='utf-8') as f:
-                generation_data = json.load(f)
-            print(f"✅ {len(generation_data)} génération(s) disponible(s)")
-            
-            if generation_data:
-                sorted_keys = sorted(generation_data.keys())
-                last_generation = generation_data[sorted_keys[-1]]
-                print(f"📝 Dernière génération: {last_generation}")
-        except Exception as e:
-            print(f"⚠️  Erreur lecture générations: {e}")
-    else:
-        print("📝 Aucune génération disponible")
-    
-    # 3. Simuler l'envoi automatique
-    print("\n🔄 Simulation de l'envoi automatique:")
-    print("   1. Surveillance des nouvelles générations")
-    print("   2. Envoi automatique avec le premier utilisateur")
-    print("   3. Suppression de la génération après envoi")
-    print("   4. Attente de 10 secondes entre chaque envoi")
-    
-    return True
-
-def demo_auto_message_interface():
-    """Démonstration de l'interface d'envoi automatique"""
-    print("\n🌐 Démonstration de l'interface:")
-    print("   1. Ouvrir http://localhost:5000")
-    print("   2. Dans le tableau de bord (sidebar gauche)")
-    print("   3. Trouver le switch 'Envoi Auto Messages'")
-    print("   4. Activer le switch pour démarrer l'envoi automatique")
-    print("   5. Les messages seront envoyés automatiquement quand des générations sont disponibles")
-    
-    print("\n📋 Fonctionnalités ajoutées:")
-    print("   ✅ Bouton slide pour l'envoi automatique de messages")
-    print("   ✅ Surveillance des générations IA")
-    print("   ✅ Envoi automatique avec le premier utilisateur")
-    print("   ✅ Suppression automatique des générations envoyées")
-    print("   ✅ Délai de 10 secondes entre chaque envoi")
-    print("   ✅ Retour en temps réel via Socket.IO")
-    print("   ✅ Gestion des erreurs d'envoi")
-
-def test_message_bot():
-    """Test du bot de messages"""
-    print("\n🤖 Test du bot de messages:")
-    
-    try:
-        from fonction.first_class import messageTwitch
-        
-        # Créer une instance du bot de messages
-        message_bot = messageTwitch("config/user.json", "default")
-        print("✅ Bot de messages créé avec succès")
-        
-        # Vérifier les utilisateurs disponibles
-        with open("config/user.json", 'r') as f:
-            users = json.load(f)
-        
-        print(f"✅ {len(users)} utilisateur(s) configuré(s)")
-        for i, user in enumerate(users):
-            print(f"   {i}: {user['tw_acc_pseudo']} {user['charactere']}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Erreur lors du test du bot: {e}")
-        return False
-
-if __name__ == '__main__':
-    print("🚀 Test du système d'envoi automatique de messages")
-    print("=" * 60)
-    
-    # Test du système de base
-    system_ok = test_auto_message_system()
-    
-    # Test du bot de messages
-    bot_ok = test_message_bot()
-    
-    # Démonstration de l'interface
-    demo_auto_message_interface()
-    
-    print("\n" + "=" * 60)
-    if system_ok and bot_ok:
-        print("✅ Test réussi !")
-        print("🎉 Le système d'envoi automatique de messages est prêt")
-        print("💡 Utilisez le switch dans l'interface web pour l'activer")
-    else:
-        print("❌ Problèmes détectés")
-        if not system_ok:
-            print("   - Problème avec le système de base")
-        if not bot_ok:
-            print("   - Problème avec le bot de messages") 
\ No newline at end of file
diff --git a/test_auto_subtitle.py b/test_auto_subtitle.py
deleted file mode 100644
index 4ba7e35..0000000
--- a/test_auto_subtitle.py
+++ /dev/null
@@ -1,154 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de test pour la génération automatique de sous-titres
-"""
-
-import subprocess
-import os
-import json
-import time
-from datetime import datetime
-
-def test_auto_subtitle_system():
-    """Test du système de génération automatique de sous-titres"""
-    print("🧪 Test du système de génération automatique de sous-titres")
-    print("=" * 60)
-    
-    # 1. Vérifier les fichiers audio disponibles
-    record_dir = "record"
-    if not os.path.exists(record_dir):
-        print(f"❌ Dossier record non trouvé: {record_dir}")
-        return False
-    
-    audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
-    if not audio_files:
-        print(f"❌ Aucun fichier audio trouvé dans {record_dir}")
-        return False
-    
-    print(f"✅ {len(audio_files)} fichiers audio trouvés")
-    print(f"📁 Premier fichier: {audio_files[0]}")
-    
-    # 2. Simuler le traitement d'un fichier
-    test_file = audio_files[0]
-    audio_path = os.path.join(record_dir, test_file)
-    
-    print(f"\n🎵 Simulation du traitement de: {test_file}")
-    
-    try:
-        # Lancer Whisper
-        command = [
-            'whisper', 
-            '--language', 'fr', 
-            audio_path,
-            '--device', 'cuda', 
-            '--model', 'large-v3'
-        ]
-        
-        print(f"📝 Commande: {' '.join(command)}")
-        print("⏳ Traitement en cours...")
-        
-        result = subprocess.run(command, capture_output=True, text=True, timeout=60)
-        
-        if result.returncode == 0:
-            print("✅ Whisper a fonctionné avec succès")
-            
-            # Lire le fichier .txt généré
-            txt_file = test_file.replace('.mp3', '.txt')
-            if os.path.exists(txt_file):
-                with open(txt_file, 'r', encoding='utf-8') as f:
-                    content = f.read().strip()
-                
-                print(f"📝 Contenu généré: {content}")
-                
-                # Nettoyer le contenu
-                content = content.replace("'", "").replace('"', "").replace("\n", " ").replace(",", "")
-                
-                # Supprimer les répétitions de mots
-                words = content.split()
-                seen = set()
-                result_words = []
-                for word in words:
-                    if word not in seen:
-                        result_words.append(word)
-                        seen.add(word)
-                cleaned_content = " ".join(result_words)
-                
-                print(f"🧹 Contenu nettoyé: {cleaned_content}")
-                
-                # Sauvegarder dans le stockage
-                current_time = datetime.now().strftime('%H:%M:%S')
-                
-                # Sauvegarder dans le fichier de stockage
-                storage_dir = "storage"
-                if not os.path.exists(storage_dir):
-                    os.makedirs(storage_dir)
-                
-                subtitle_file = os.path.join(storage_dir, "subtitle_data.json")
-                try:
-                    with open(subtitle_file, 'r', encoding='utf-8') as f:
-                        existing_data = json.load(f)
-                except (FileNotFoundError, json.JSONDecodeError):
-                    existing_data = {}
-                
-                existing_data[current_time] = cleaned_content
-                
-                with open(subtitle_file, 'w', encoding='utf-8') as f:
-                    json.dump(existing_data, f, indent=4, ensure_ascii=False)
-                
-                print(f"💾 Sous-titre sauvegardé à {current_time}")
-                
-                # Nettoyer les fichiers temporaires
-                os.remove(txt_file)
-                print("🧹 Fichier temporaire nettoyé")
-                
-                return True
-            else:
-                print("⚠️  Aucun fichier .txt généré")
-                return False
-        else:
-            print(f"❌ Erreur Whisper: {result.stderr}")
-            return False
-            
-    except subprocess.TimeoutExpired:
-        print("⏰ Timeout - Whisper a pris trop de temps")
-        return False
-    except Exception as e:
-        print(f"❌ Erreur: {e}")
-        return False
-
-def demo_auto_subtitle_interface():
-    """Démonstration de l'interface de génération automatique"""
-    print("\n🌐 Démonstration de l'interface:")
-    print("   1. Ouvrir http://localhost:5000")
-    print("   2. Dans le tableau de bord (sidebar gauche)")
-    print("   3. Trouver le switch 'Génération Auto Sous-titres'")
-    print("   4. Activer le switch pour démarrer la génération automatique")
-    print("   5. Aller dans l'onglet 'Sous-titres' pour voir le fichier en cours")
-    print("   6. Les sous-titres seront créés automatiquement fichier par fichier")
-    
-    print("\n📋 Fonctionnalités ajoutées:")
-    print("   ✅ Bouton slide dans le tableau de bord")
-    print("   ✅ Indicateur de fichier en cours de traitement")
-    print("   ✅ Traitement automatique fichier par fichier")
-    print("   ✅ Retour en temps réel via Socket.IO")
-    print("   ✅ Sauvegarde automatique dans le stockage")
-    print("   ✅ Nettoyage automatique des fichiers temporaires")
-
-if __name__ == '__main__':
-    print("🚀 Test du système de génération automatique de sous-titres")
-    print("=" * 60)
-    
-    # Test du traitement automatique
-    success = test_auto_subtitle_system()
-    
-    # Démonstration de l'interface
-    demo_auto_subtitle_interface()
-    
-    print("\n" + "=" * 60)
-    if success:
-        print("✅ Test réussi !")
-        print("🎉 Le système de génération automatique est prêt")
-        print("💡 Utilisez le switch dans l'interface web pour l'activer")
-    else:
-        print("❌ Test échoué !")
-        print("🔧 Vérifiez que Whisper fonctionne correctement") 
\ No newline at end of file
diff --git a/test_chat_toggle.py b/test_chat_toggle.py
deleted file mode 100644
index 06f401d..0000000
--- a/test_chat_toggle.py
+++ /dev/null
@@ -1,109 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de test pour vérifier le toggle d'envoi de messages chat
-"""
-
-import requests
-import json
-import time
-
-BASE_URL = "http://localhost:5000"
-
-def test_chat_messages_toggle():
-    """Test du toggle d'envoi de messages chat"""
-    print("🧪 Test du toggle d'envoi de messages chat")
-    print("=" * 50)
-    
-    # Test 1: Vérifier le statut initial
-    print("1. Vérification du statut initial...")
-    try:
-        response = requests.get(f"{BASE_URL}/api/chat/messages/status")
-        if response.status_code == 200:
-            status = response.json()
-            print(f"   ✓ Statut initial: {'Activé' if status['enabled'] else 'Désactivé'}")
-        else:
-            print(f"   ✗ Erreur: {response.status_code}")
-            return False
-    except Exception as e:
-        print(f"   ✗ Erreur de connexion: {e}")
-        return False
-    
-    # Test 2: Désactiver l'envoi de messages
-    print("2. Désactivation de l'envoi de messages...")
-    try:
-        response = requests.post(f"{BASE_URL}/api/chat/messages/disable")
-        if response.status_code == 200:
-            result = response.json()
-            print(f"   ✓ {result['message']}")
-        else:
-            print(f"   ✗ Erreur: {response.status_code}")
-            return False
-    except Exception as e:
-        print(f"   ✗ Erreur: {e}")
-        return False
-    
-    # Test 3: Vérifier que c'est bien désactivé
-    print("3. Vérification de la désactivation...")
-    try:
-        response = requests.get(f"{BASE_URL}/api/chat/messages/status")
-        if response.status_code == 200:
-            status = response.json()
-            if not status['enabled']:
-                print("   ✓ Envoi de messages désactivé avec succès")
-            else:
-                print("   ✗ L'envoi de messages n'a pas été désactivé")
-                return False
-        else:
-            print(f"   ✗ Erreur: {response.status_code}")
-            return False
-    except Exception as e:
-        print(f"   ✗ Erreur: {e}")
-        return False
-    
-    # Test 4: Réactiver l'envoi de messages
-    print("4. Réactivation de l'envoi de messages...")
-    try:
-        response = requests.post(f"{BASE_URL}/api/chat/messages/enable")
-        if response.status_code == 200:
-            result = response.json()
-            print(f"   ✓ {result['message']}")
-        else:
-            print(f"   ✗ Erreur: {response.status_code}")
-            return False
-    except Exception as e:
-        print(f"   ✗ Erreur: {e}")
-        return False
-    
-    # Test 5: Vérifier que c'est bien réactivé
-    print("5. Vérification de la réactivation...")
-    try:
-        response = requests.get(f"{BASE_URL}/api/chat/messages/status")
-        if response.status_code == 200:
-            status = response.json()
-            if status['enabled']:
-                print("   ✓ Envoi de messages réactivé avec succès")
-            else:
-                print("   ✗ L'envoi de messages n'a pas été réactivé")
-                return False
-        else:
-            print(f"   ✗ Erreur: {response.status_code}")
-            return False
-    except Exception as e:
-        print(f"   ✗ Erreur: {e}")
-        return False
-    
-    print("=" * 50)
-    print("✅ Tous les tests sont passés avec succès !")
-    return True
-
-if __name__ == "__main__":
-    print("🤖 Test du système de toggle d'envoi de messages")
-    print("Assurez-vous que le serveur web est démarré sur http://localhost:5000")
-    print()
-    
-    success = test_chat_messages_toggle()
-    
-    if success:
-        print("\n🎉 Le toggle d'envoi de messages fonctionne correctement !")
-    else:
-        print("\n❌ Des erreurs ont été détectées lors des tests.") 
\ No newline at end of file
diff --git a/test_manual_api.py b/test_manual_api.py
deleted file mode 100644
index 0be976b..0000000
--- a/test_manual_api.py
+++ /dev/null
@@ -1,129 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de test pour simuler l'API de traitement manuel des sous-titres
-"""
-
-import subprocess
-import os
-import json
-from datetime import datetime
-
-def process_subtitles_manual():
-    """Simuler le traitement manuel des sous-titres"""
-    print("🧪 Test du traitement manuel des sous-titres")
-    print("=" * 50)
-    
-    # Vérifier que le dossier record existe
-    record_dir = "record"
-    if not os.path.exists(record_dir):
-        print(f"❌ Dossier record non trouvé: {record_dir}")
-        return False
-    
-    # Trouver les fichiers audio
-    audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
-    if not audio_files:
-        print(f"❌ Aucun fichier audio trouvé dans {record_dir}")
-        return False
-    
-    print(f"✅ {len(audio_files)} fichiers audio trouvés")
-    
-    subtitles_created = 0
-    subtitles_data = {}
-    
-    # Traiter chaque fichier audio (limiter à 2 pour le test)
-    for audio_file in audio_files[:2]:
-        audio_path = os.path.join(record_dir, audio_file)
-        print(f"🎵 Traitement de: {audio_file}")
-        
-        try:
-            # Lancer Whisper
-            command = [
-                'whisper', 
-                '--language', 'fr', 
-                audio_path,
-                '--device', 'cuda', 
-                '--model', 'large-v3'
-            ]
-            
-            print(f"📝 Commande: {' '.join(command)}")
-            result = subprocess.run(command, capture_output=True, text=True, timeout=60)
-            
-            if result.returncode == 0:
-                # Lire le fichier .txt généré
-                txt_file = audio_file.replace('.mp3', '.txt')
-                if os.path.exists(txt_file):
-                    with open(txt_file, 'r', encoding='utf-8') as f:
-                        content = f.read().strip()
-                    
-                    print(f"📝 Contenu brut: {content}")
-                    
-                    # Nettoyer le contenu
-                    content = content.replace("'", "").replace('"', "").replace("\n", " ").replace(",", "")
-                    
-                    # Supprimer les répétitions de mots
-                    words = content.split()
-                    seen = set()
-                    result_words = []
-                    for word in words:
-                        if word not in seen:
-                            result_words.append(word)
-                            seen.add(word)
-                    cleaned_content = " ".join(result_words)
-                    
-                    print(f"🧹 Contenu nettoyé: {cleaned_content}")
-                    
-                    # Sauvegarder dans le stockage
-                    current_time = datetime.now().strftime('%H:%M:%S')
-                    subtitles_data[current_time] = cleaned_content
-                    
-                    # Sauvegarder dans le fichier de stockage
-                    storage_dir = "storage"
-                    if not os.path.exists(storage_dir):
-                        os.makedirs(storage_dir)
-                    
-                    subtitle_file = os.path.join(storage_dir, "subtitle_data.json")
-                    try:
-                        with open(subtitle_file, 'r', encoding='utf-8') as f:
-                            existing_data = json.load(f)
-                    except (FileNotFoundError, json.JSONDecodeError):
-                        existing_data = {}
-                    
-                    existing_data[current_time] = cleaned_content
-                    
-                    with open(subtitle_file, 'w', encoding='utf-8') as f:
-                        json.dump(existing_data, f, indent=4, ensure_ascii=False)
-                    
-                    subtitles_created += 1
-                    print(f"✅ Sous-titre créé et sauvegardé")
-                    
-                    # Nettoyer les fichiers temporaires
-                    os.remove(txt_file)
-                    os.remove(audio_path)  # Supprimer le fichier audio traité
-                    print(f"🧹 Fichiers temporaires nettoyés")
-                    
-                else:
-                    print(f"⚠️  Aucun fichier .txt généré pour {audio_file}")
-                    
-            else:
-                print(f"❌ Erreur Whisper: {result.stderr}")
-                
-        except subprocess.TimeoutExpired:
-            print(f"⏰ Timeout pour {audio_file}")
-            continue
-        except Exception as e:
-            print(f"❌ Erreur pour {audio_file}: {e}")
-            continue
-    
-    print(f"\n📊 Résumé: {subtitles_created} sous-titre(s) créé(s)")
-    print("📝 Sous-titres générés:")
-    for time_key, text in subtitles_data.items():
-        print(f"   {time_key}: {text}")
-    
-    return subtitles_created > 0
-
-if __name__ == '__main__':
-    success = process_subtitles_manual()
-    if success:
-        print("\n✅ Test réussi ! Le traitement manuel fonctionne.")
-    else:
-        print("\n❌ Test échoué !") 
\ No newline at end of file
diff --git a/test_manual_subtitle.py b/test_manual_subtitle.py
deleted file mode 100644
index acf1cad..0000000
--- a/test_manual_subtitle.py
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de test pour le traitement manuel des sous-titres
-"""
-
-import os
-import sys
-import json
-
-# Ajouter le chemin vers les modules
-sys.path.append('.')
-
-def test_manual_subtitle_processing():
-    """Test du traitement manuel des sous-titres"""
-    print("🧪 Test du traitement manuel des sous-titres")
-    print("=" * 50)
-    
-    # Vérifier que le fichier de configuration existe
-    config_file = "config/config.json"
-    if not os.path.exists(config_file):
-        print(f"❌ Fichier de configuration non trouvé: {config_file}")
-        return False
-    
-    # Vérifier que le dossier record existe et contient des fichiers
-    record_dir = "record"
-    if not os.path.exists(record_dir):
-        print(f"❌ Dossier record non trouvé: {record_dir}")
-        return False
-    
-    audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
-    if not audio_files:
-        print(f"❌ Aucun fichier audio trouvé dans {record_dir}")
-        return False
-    
-    print(f"✅ {len(audio_files)} fichiers audio trouvés")
-    print("📁 Fichiers audio disponibles:")
-    for file in audio_files[:5]:  # Afficher les 5 premiers fichiers
-        print(f"   - {file}")
-    
-    # Créer une instance du bot de sous-titres
-    try:
-        from fonction.first_class import Subtitle_translation
-        
-        subtitle_bot = Subtitle_translation(config_file)
-        print("✅ Bot de sous-titres créé avec succès")
-        
-        # Lancer le traitement manuel
-        print("🔍 Lancement du traitement manuel...")
-        subtitle_bot.verif_file_transcribe()
-        
-        # Vérifier si des sous-titres ont été créés
-        if subtitle_bot.subtitle:
-            print("✅ Sous-titres créés avec succès")
-            print("📝 Sous-titres générés:")
-            for time_key, text in subtitle_bot.subtitle.items():
-                print(f"   {time_key}: {text}")
-        else:
-            print("⚠️  Aucun sous-titre créé")
-        
-        # Vérifier le stockage
-        from fonction.first_class import storage
-        subtitle_data = storage.read("subtitle_data")
-        if subtitle_data:
-            print(f"💾 {len(subtitle_data)} sous-titre(s) sauvegardé(s) dans le stockage")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Erreur lors du test: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == '__main__':
-    success = test_manual_subtitle_processing()
-    if success:
-        print("\n✅ Test réussi !")
-    else:
-        print("\n❌ Test échoué !") 
\ No newline at end of file
diff --git a/test_message.py b/test_message.py
deleted file mode 100644
index 12fd0a4..0000000
--- a/test_message.py
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de test pour vérifier l'envoi de messages
-"""
-
-import sys
-import os
-
-# Ajouter le chemin vers les modules
-sys.path.append('.')
-
-from fonction.first_class import messageTwitch
-
-def test_send_message():
-    """Test de l'envoi de message"""
-    try:
-        # Créer une instance de messageTwitch
-        msg_bot = messageTwitch("config/user.json", "test_channel")
-        
-        # Tester l'envoi d'un message
-        print("Test d'envoi de message...")
-        msg_bot.send_message("Test message from bot")
-        print("✓ Test réussi !")
-        
-    except Exception as e:
-        print(f"✗ Erreur lors du test: {e}")
-        return False
-    
-    return True
-
-if __name__ == "__main__":
-    print("🧪 Test de l'envoi de messages")
-    print("=" * 40)
-    
-    if test_send_message():
-        print("\n✅ Tous les tests sont passés !")
-    else:
-        print("\n❌ Certains tests ont échoué.") 
\ No newline at end of file
diff --git a/test_subtitle_bot.py b/test_subtitle_bot.py
deleted file mode 100644
index 45d0dfb..0000000
--- a/test_subtitle_bot.py
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de test pour vérifier le fonctionnement du bot de sous-titres
-"""
-
-import os
-import sys
-import time
-
-# Ajouter le chemin vers les modules
-sys.path.append('.')
-
-from fonction.first_class import Subtitle_translation
-
-def test_subtitle_bot():
-    """Test du bot de sous-titres"""
-    print("🧪 Test du bot de sous-titres")
-    print("=" * 50)
-    
-    # Vérifier que le fichier de configuration existe
-    config_file = "config/config.json"
-    if not os.path.exists(config_file):
-        print(f"❌ Fichier de configuration non trouvé: {config_file}")
-        return False
-    
-    # Vérifier que le dossier record existe et contient des fichiers
-    record_dir = "record"
-    if not os.path.exists(record_dir):
-        print(f"❌ Dossier record non trouvé: {record_dir}")
-        return False
-    
-    audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
-    if not audio_files:
-        print(f"❌ Aucun fichier audio trouvé dans {record_dir}")
-        return False
-    
-    print(f"✅ {len(audio_files)} fichiers audio trouvés")
-    
-    # Créer une instance du bot de sous-titres
-    try:
-        subtitle_bot = Subtitle_translation(config_file)
-        print("✅ Bot de sous-titres créé avec succès")
-        
-        # Tester la méthode verif_file_transcribe
-        print("🔍 Test de la vérification des fichiers...")
-        subtitle_bot.verif_file_transcribe()
-        
-        # Vérifier si des sous-titres ont été créés
-        if subtitle_bot.subtitle:
-            print("✅ Sous-titres créés avec succès")
-            for time_key, text in subtitle_bot.subtitle.items():
-                print(f"   {time_key}: {text}")
-        else:
-            print("⚠️  Aucun sous-titre créé")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Erreur lors du test: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == '__main__':
-    success = test_subtitle_bot()
-    if success:
-        print("\n✅ Test réussi !")
-    else:
-        print("\n❌ Test échoué !") 
\ No newline at end of file
diff --git a/test_whisper_direct.py b/test_whisper_direct.py
deleted file mode 100644
index 3de58ee..0000000
--- a/test_whisper_direct.py
+++ /dev/null
@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script de test direct de Whisper pour la création de sous-titres
-"""
-
-import os
-import subprocess
-import json
-import time
-
-def test_whisper_direct():
-    """Test direct de Whisper"""
-    print("🧪 Test direct de Whisper")
-    print("=" * 50)
-    
-    # Vérifier que le dossier record existe et contient des fichiers
-    record_dir = "record"
-    if not os.path.exists(record_dir):
-        print(f"❌ Dossier record non trouvé: {record_dir}")
-        return False
-    
-    audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
-    if not audio_files:
-        print(f"❌ Aucun fichier audio trouvé dans {record_dir}")
-        return False
-    
-    print(f"✅ {len(audio_files)} fichiers audio trouvés")
-    
-    # Prendre le premier fichier pour le test
-    test_file = audio_files[0]
-    test_file_path = os.path.join(record_dir, test_file)
-    
-    print(f"🎵 Test avec le fichier: {test_file}")
-    
-    # Test direct de Whisper
-    try:
-        print("🔍 Lancement de Whisper...")
-        command = [
-            'whisper', 
-            '--language', 'fr', 
-            test_file_path,
-            '--device', 'cuda', 
-            '--model', 'large-v3'
-        ]
-        
-        print(f"📝 Commande: {' '.join(command)}")
-        
-        # Exécuter Whisper
-        result = subprocess.run(command, capture_output=True, text=True, timeout=60)
-        
-        if result.returncode == 0:
-            print("✅ Whisper a fonctionné avec succès")
-            
-            # Vérifier si un fichier .txt a été créé
-            txt_file = test_file.replace('.mp3', '.txt')
-            if os.path.exists(txt_file):
-                with open(txt_file, 'r', encoding='utf-8') as f:
-                    content = f.read().strip()
-                print(f"📝 Contenu généré: {content}")
-                
-                # Nettoyer le fichier de test
-                os.remove(txt_file)
-                print("🧹 Fichier de test nettoyé")
-                
-                return True
-            else:
-                print("⚠️  Aucun fichier .txt généré")
-                return False
-        else:
-            print(f"❌ Erreur Whisper: {result.stderr}")
-            return False
-            
-    except subprocess.TimeoutExpired:
-        print("⏰ Timeout - Whisper a pris trop de temps")
-        return False
-    except Exception as e:
-        print(f"❌ Erreur: {e}")
-        return False
-
-def test_subtitle_storage():
-    """Test du stockage des sous-titres"""
-    print("\n🧪 Test du stockage des sous-titres")
-    print("=" * 50)
-    
-    # Créer un fichier de test pour le stockage
-    storage_dir = "storage"
-    if not os.path.exists(storage_dir):
-        os.makedirs(storage_dir)
-        print(f"✅ Dossier storage créé: {storage_dir}")
-    
-    # Test d'écriture/lecture
-    test_data = {
-        "test_time": "Test de sous-titre",
-        "test_time_2": "Deuxième test"
-    }
-    
-    subtitle_file = os.path.join(storage_dir, "subtitle_data.json")
-    
-    try:
-        # Écrire des données de test
-        with open(subtitle_file, 'w', encoding='utf-8') as f:
-            json.dump(test_data, f, indent=4, ensure_ascii=False)
-        print("✅ Données de test écrites")
-        
-        # Lire les données
-        with open(subtitle_file, 'r', encoding='utf-8') as f:
-            read_data = json.load(f)
-        
-        if read_data == test_data:
-            print("✅ Lecture/écriture du stockage OK")
-            return True
-        else:
-            print("❌ Données lues différentes des données écrites")
-            return False
-            
-    except Exception as e:
-        print(f"❌ Erreur stockage: {e}")
-        return False
-
-if __name__ == '__main__':
-    print("🚀 Test complet du système de sous-titres")
-    print("=" * 60)
-    
-    # Test 1: Whisper direct
-    whisper_ok = test_whisper_direct()
-    
-    # Test 2: Stockage
-    storage_ok = test_subtitle_storage()
-    
-    print("\n" + "=" * 60)
-    if whisper_ok and storage_ok:
-        print("✅ Tous les tests sont réussis !")
-        print("🎉 Le système de sous-titres est prêt à fonctionner")
-    else:
-        print("❌ Certains tests ont échoué")
-        if not whisper_ok:
-            print("   - Whisper ne fonctionne pas correctement")
-        if not storage_ok:
-            print("   - Le stockage ne fonctionne pas correctement") 
\ No newline at end of file
diff --git a/web_interface.py b/web_interface.py
index 5aede19..6ce3495 100644
--- a/web_interface.py
+++ b/web_interface.py
@@ -25,6 +25,10 @@ class BotController:
         self.bots = {}  # Stockage des instances de bots (pour l'utilisation interne)
         self.flux_list = []  # Liste des flux surveillés (pour l'API JSON)
         self.config = self.load_config()
+        self.ia_generator = None
+        self.control_twitch = None
+        self.ia_generator_running = False
+        self.control_twitch_running = False
         
     def load_config(self):
         try:
@@ -37,6 +41,21 @@ class BotController:
         with open('config/config.json', 'w') as file:
             json.dump(self.config, file, indent=4, ensure_ascii=False)
     
+    def get_system_status(self):
+        """Obtenir le statut de tous les composants"""
+        return {
+            'ia_generator': {
+                'running': self.ia_generator_running,
+                'status': 'En cours' if self.ia_generator_running else 'Arrêté'
+            },
+            'control_twitch': {
+                'running': self.control_twitch_running,
+                'status': 'En cours' if self.control_twitch_running else 'Arrêté'
+            },
+            'flux_count': len(self.flux_list),
+            'active_flux': len([f for f in self.flux_list if f['active']])
+        }
+    
     def add_flux(self, channel_name, record_audio=True):
         flux_id = len(self.flux_list) + 1
         
@@ -140,6 +159,112 @@ class BotController:
         # Retourner seulement les données JSON (pas les instances de bots)
         return self.flux_list
 
+    def start_ia_generator(self):
+        """Démarrer le générateur IA de manière contrôlée"""
+        if self.ia_generator_running:
+            return False, "IA Generator déjà en cours d'exécution"
+        
+        try:
+            self.ia_generator = IA_generator("config/config.json")
+            self.ia_generator_running = True
+            
+            # Activer l'envoi de messages quand l'IA Generator est démarré
+            global chat_messages_enabled
+            chat_messages_enabled = True
+            
+            # Démarrer dans un thread séparé
+            threading.Thread(target=self._ia_generator_loop, daemon=True).start()
+            
+            print(f"[{datetime.now().strftime('%H:%M:%S')}] IA Generator démarré")
+            return True, "IA Generator démarré avec succès"
+        except Exception as e:
+            self.ia_generator_running = False
+            return False, f"Erreur lors du démarrage de l'IA Generator: {str(e)}"
+    
+    def stop_ia_generator(self):
+        """Arrêter le générateur IA"""
+        if not self.ia_generator_running:
+            return False, "IA Generator n'est pas en cours d'exécution"
+        
+        try:
+            self.ia_generator_running = False
+            if self.ia_generator:
+                self.ia_generator.stop()
+            
+            # Désactiver l'envoi de messages quand l'IA Generator est arrêté
+            global chat_messages_enabled
+            chat_messages_enabled = False
+            
+            print(f"[{datetime.now().strftime('%H:%M:%S')}] IA Generator arrêté")
+            return True, "IA Generator arrêté avec succès"
+        except Exception as e:
+            return False, f"Erreur lors de l'arrêt de l'IA Generator: {str(e)}"
+    
+    def _ia_generator_loop(self):
+        """Boucle contrôlée pour l'IA Generator"""
+        while self.ia_generator_running:
+            try:
+                if self.ia_generator:
+                    self.ia_generator.main_ask("")  # Génération automatique
+                time.sleep(20)  # Attendre 20 secondes entre les générations
+            except Exception as e:
+                print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur dans IA Generator: {e}")
+                time.sleep(10)
+    
+    def start_control_twitch(self):
+        """Démarrer le contrôleur Twitch de manière contrôlée"""
+        if self.control_twitch_running:
+            return False, "Control Twitch déjà en cours d'exécution"
+        
+        try:
+            # Utiliser le premier utilisateur par défaut
+            self.control_twitch = messageTwitch("config/user.json", "default")
+            self.control_twitch_running = True
+            
+            # Démarrer dans un thread séparé
+            threading.Thread(target=self._control_twitch_loop, daemon=True).start()
+            
+            print(f"[{datetime.now().strftime('%H:%M:%S')}] Control Twitch démarré")
+            return True, "Control Twitch démarré avec succès"
+        except Exception as e:
+            self.control_twitch_running = False
+            return False, f"Erreur lors du démarrage de Control Twitch: {str(e)}"
+    
+    def stop_control_twitch(self):
+        """Arrêter le contrôleur Twitch"""
+        if not self.control_twitch_running:
+            return False, "Control Twitch n'est pas en cours d'exécution"
+        
+        try:
+            self.control_twitch_running = False
+            if self.control_twitch:
+                self.control_twitch.stop()
+            print(f"[{datetime.now().strftime('%H:%M:%S')}] Control Twitch arrêté")
+            return True, "Control Twitch arrêté avec succès"
+        except Exception as e:
+            return False, f"Erreur lors de l'arrêt de Control Twitch: {str(e)}"
+    
+    def _control_twitch_loop(self):
+        """Boucle contrôlée pour Control Twitch"""
+        while self.control_twitch_running:
+            try:
+                if self.control_twitch:
+                    # Vérifier s'il y a des générations à envoyer
+                    generation_data = storage.read("IA_generator")
+                    if generation_data:
+                        sorted_keys = sorted(generation_data.keys())
+                        if sorted_keys:
+                            last_generation = generation_data[sorted_keys[-1]]
+                            # Envoyer le message avec le premier utilisateur
+                            self.control_twitch.send_message_user(0, last_generation)
+                            # Supprimer la génération envoyée
+                            storage.delete("IA_generator", sorted_keys[-1])
+                            print(f"[{datetime.now().strftime('%H:%M:%S')}] Message envoyé: {last_generation[:50]}...")
+                time.sleep(10)  # Attendre 10 secondes entre les vérifications
+            except Exception as e:
+                print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur dans Control Twitch: {e}")
+                time.sleep(10)
+
 bot_controller = BotController()
 
 @app.route('/')
@@ -372,6 +497,33 @@ def get_subtitles():
     data = storage.read("subtitle_data")
     return jsonify(data)
 
+@app.route('/api/subtitles/clear', methods=['POST'])
+def clear_subtitles():
+    """Nettoyer l'historique des sous-titres"""
+    try:
+        # Récupérer toutes les clés de sous-titres
+        subtitle_data = storage.read("subtitle_data")
+        
+        # Supprimer chaque clé une par une
+        for key in list(subtitle_data.keys()):
+            storage.delete("subtitle_data", key)
+        
+        # Supprimer également le fichier JSON s'il existe
+        storage_dir = "storage"
+        subtitle_file = os.path.join(storage_dir, "subtitle_data.json")
+        if os.path.exists(subtitle_file):
+            os.remove(subtitle_file)
+        
+        return jsonify({
+            'success': True,
+            'message': 'Historique des sous-titres nettoyé avec succès'
+        })
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': f'Erreur lors du nettoyage: {str(e)}'
+        }), 500
+
 @app.route('/api/subtitles/process', methods=['POST'])
 def process_subtitles():
     """Lancer manuellement le traitement des sous-titres"""
@@ -643,21 +795,32 @@ auto_message_running = False
 current_message_bot = None
 
 # Variable globale pour contrôler l'envoi de messages dans le chat
-chat_messages_enabled = True
+chat_messages_enabled = False
 
 @app.route('/api/subtitles/auto/start', methods=['POST'])
 def start_auto_subtitle():
     """Démarrer la génération automatique de sous-titres"""
     global auto_subtitle_running
     try:
+        # Vérifier si déjà en cours
+        if auto_subtitle_running:
+            return jsonify({
+                'success': False,
+                'error': 'La génération automatique est déjà en cours'
+            }), 400
+        
         auto_subtitle_running = True
+        print(f"[{datetime.now().strftime('%H:%M:%S')}] Démarrage de la génération automatique de sous-titres")
+        
         # Démarrer le thread de génération automatique
         threading.Thread(target=auto_subtitle_loop, daemon=True).start()
+        
         return jsonify({
             'success': True,
             'message': 'Génération automatique démarrée'
         })
     except Exception as e:
+        auto_subtitle_running = False
         return jsonify({
             'success': False,
             'error': f'Erreur lors du démarrage: {str(e)}'
@@ -668,7 +831,15 @@ def stop_auto_subtitle():
     """Arrêter la génération automatique de sous-titres"""
     global auto_subtitle_running
     try:
+        if not auto_subtitle_running:
+            return jsonify({
+                'success': False,
+                'error': 'La génération automatique n\'est pas en cours'
+            }), 400
+        
+        print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt de la génération automatique de sous-titres")
         auto_subtitle_running = False
+        
         return jsonify({
             'success': True,
             'message': 'Génération automatique arrêtée'
@@ -679,6 +850,25 @@ def stop_auto_subtitle():
             'error': f'Erreur lors de l\'arrêt: {str(e)}'
         }), 500
 
+@app.route('/api/subtitles/auto/force-stop', methods=['POST'])
+def force_stop_auto_subtitle():
+    """Forcer l'arrêt de la génération automatique de sous-titres"""
+    global auto_subtitle_running, current_processing_file
+    try:
+        print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt forcé de la génération automatique de sous-titres")
+        auto_subtitle_running = False
+        current_processing_file = None
+        
+        return jsonify({
+            'success': True,
+            'message': 'Arrêt forcé de la génération automatique de sous-titres'
+        })
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': f'Erreur lors de l\'arrêt forcé: {str(e)}'
+        }), 500
+
 @app.route('/api/subtitles/auto/status', methods=['GET'])
 def get_auto_subtitle_status():
     """Obtenir le statut de la génération automatique"""
@@ -692,6 +882,8 @@ def auto_subtitle_loop():
     """Boucle de génération automatique de sous-titres"""
     global auto_subtitle_running, current_processing_file
     
+    print(f"[{datetime.now().strftime('%H:%M:%S')}] Démarrage de la boucle de génération automatique de sous-titres")
+    
     while auto_subtitle_running:
         try:
             # Vérifier s'il y a des fichiers audio à traiter
@@ -709,6 +901,8 @@ def auto_subtitle_loop():
             audio_file = audio_files[0]
             current_processing_file = audio_file
             
+            print(f"[{datetime.now().strftime('%H:%M:%S')}] Traitement de: {audio_file}")
+            
             # Émettre l'événement de début de traitement
             socketio.emit('subtitle_processing_start', {
                 'file': audio_file,
@@ -719,7 +913,7 @@ def auto_subtitle_loop():
             audio_path = os.path.join(record_dir, audio_file)
             
             try:
-                # Lancer Whisper
+                # Lancer Whisper avec vérification périodique de l'arrêt
                 command = [
                     'whisper', 
                     '--language', 'fr', 
@@ -728,9 +922,30 @@ def auto_subtitle_loop():
                     '--model', 'large-v3'
                 ]
                 
-                result = subprocess.run(command, capture_output=True, text=True, timeout=60)
+                # Utiliser Popen pour pouvoir interrompre le processus
+                process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
                 
-                if result.returncode == 0:
+                # Attendre la fin du processus avec vérification périodique
+                while process.poll() is None:
+                    if not auto_subtitle_running:
+                        print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt demandé, interruption du processus Whisper")
+                        process.terminate()
+                        try:
+                            process.wait(timeout=5)
+                        except subprocess.TimeoutExpired:
+                            process.kill()
+                        break
+                    time.sleep(1)
+                
+                # Si la boucle a été arrêtée, sortir
+                if not auto_subtitle_running:
+                    print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt de la boucle de génération automatique")
+                    break
+                
+                result = process.returncode
+                stdout, stderr = process.communicate()
+                
+                if result == 0:
                     # Lire le fichier .txt généré
                     txt_file = audio_file.replace('.mp3', '.txt')
                     if os.path.exists(txt_file):
@@ -777,6 +992,8 @@ def auto_subtitle_loop():
                             'timestamp': current_time
                         })
                         
+                        print(f"[{datetime.now().strftime('%H:%M:%S')}] Sous-titre généré: {cleaned_content}")
+                        
                         # Nettoyer les fichiers temporaires
                         os.remove(txt_file)
                         os.remove(audio_path)
@@ -787,38 +1004,49 @@ def auto_subtitle_loop():
                             'file': audio_file,
                             'error': 'Aucun fichier .txt généré'
                         })
+                        print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur: Aucun fichier .txt généré")
                         
                 else:
                     # Émettre l'événement d'erreur
                     socketio.emit('subtitle_processing_error', {
                         'file': audio_file,
-                        'error': f'Erreur Whisper: {result.stderr}'
+                        'error': f'Erreur Whisper: {stderr}'
                     })
+                    print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur Whisper: {stderr}")
                     
             except subprocess.TimeoutExpired:
                 socketio.emit('subtitle_processing_error', {
                     'file': audio_file,
                     'error': 'Timeout - Whisper a pris trop de temps'
                 })
+                print(f"[{datetime.now().strftime('%H:%M:%S')}] Timeout - Whisper a pris trop de temps")
             except Exception as e:
                 socketio.emit('subtitle_processing_error', {
                     'file': audio_file,
                     'error': f'Erreur: {str(e)}'
                 })
+                print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur lors du traitement: {str(e)}")
             
             current_processing_file = None
             
+            # Vérifier à nouveau si la boucle doit continuer
+            if not auto_subtitle_running:
+                print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt de la boucle de génération automatique")
+                break
+            
             # Attendre avant de traiter le prochain fichier
             time.sleep(2)
             
         except Exception as e:
-            print(f"Erreur dans la boucle de génération automatique: {e}")
+            print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur dans la boucle de génération automatique: {e}")
             time.sleep(5)
+    
+    print(f"[{datetime.now().strftime('%H:%M:%S')}] Fin de la boucle de génération automatique de sous-titres")
 
 @app.route('/api/messages/auto/start', methods=['POST'])
 def start_auto_message():
     """Démarrer l'envoi automatique de messages"""
-    global auto_message_running, current_message_bot
+    global auto_message_running
     try:
         # Vérifier si déjà en cours
         if auto_message_running:
@@ -1013,6 +1241,47 @@ def get_chat_messages_status():
         'enabled': chat_messages_enabled
     })
 
+@app.route('/api/system-status', methods=['GET'])
+def get_system_status():
+    """Obtenir le statut de tous les composants"""
+    return jsonify(bot_controller.get_system_status())
+
+@app.route('/api/ia-generator/start', methods=['POST'])
+def start_ia_generator():
+    """Démarrer le générateur IA"""
+    success, message = bot_controller.start_ia_generator()
+    if success:
+        # Synchroniser l'état de l'interface web
+        socketio.emit('ia_generator_status_changed', {
+            'running': True,
+            'message': message
+        })
+    return jsonify({'success': success, 'message': message})
+
+@app.route('/api/ia-generator/stop', methods=['POST'])
+def stop_ia_generator():
+    """Arrêter le générateur IA"""
+    success, message = bot_controller.stop_ia_generator()
+    if success:
+        # Synchroniser l'état de l'interface web
+        socketio.emit('ia_generator_status_changed', {
+            'running': False,
+            'message': message
+        })
+    return jsonify({'success': success, 'message': message})
+
+@app.route('/api/control-twitch/start', methods=['POST'])
+def start_control_twitch():
+    """Démarrer le contrôleur Twitch"""
+    success, message = bot_controller.start_control_twitch()
+    return jsonify({'success': success, 'message': message})
+
+@app.route('/api/control-twitch/stop', methods=['POST'])
+def stop_control_twitch():
+    """Arrêter le contrôleur Twitch"""
+    success, message = bot_controller.stop_control_twitch()
+    return jsonify({'success': success, 'message': message})
+
 if __name__ == '__main__':
     # Démarrer les mises à jour en arrière-plan
     update_thread = threading.Thread(target=background_updates, daemon=True)
diff --git a/working_bot/storage/IA_generator.json b/working_bot/storage/IA_generator.json
deleted file mode 100644
index abeb4ab..0000000
--- a/working_bot/storage/IA_generator.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "14h30m20s": "Salut ! Ça va super bien merci ! 😊",
-    "14h31m28s": "Ce jeu a l'air génial, bonne chance !",
-    "14h32m50s": "Ça arrive aux meilleurs, tu vas y arriver !",
-    "14h33m15s": "Bienvenue dans la communauté ! 🎉",
-    "14h34m35s": "Waouh cette action était épique ! 🔥",
-    "14h35m25s": "Bonne idée, change de tactique !",
-    "14h36m10s": "Bravo ! Tu maîtrises de mieux en mieux",
-    "14h37m28s": "Toujours là pour aider ! 💪",
-    "01h40m18s": "Plot twist inattendu ! 😮"
-}
\ No newline at end of file
diff --git a/working_bot/storage/subtitle_data.json b/working_bot/storage/subtitle_data.json
deleted file mode 100644
index c5329b5..0000000
--- a/working_bot/storage/subtitle_data.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "14h30m15s": "Salut les viewers ! Comment ça va aujourd'hui ?",
-    "14h31m22s": "On va jouer à ce nouveau jeu, j'ai hâte de voir ce que ça donne",
-    "14h32m45s": "Oh non, je suis mort déjà ! C'est plus dur que je pensais",
-    "14h33m12s": "Merci pour le follow @nouveau_viewer !",
-    "14h34m30s": "Cette partie est vraiment intense, regardez ça !",
-    "14h35m18s": "Je pense qu'on devrait essayer une autre stratégie",
-    "14h36m05s": "Excellent, on progresse enfin dans ce niveau",
-    "14h37m22s": "N'hésitez pas à poser vos questions dans le chat",
-    "01h40m18s": "Vous avez vu cette action incroyable ?"
-}
\ No newline at end of file