9.0 KiB
9.0 KiB
Guide d'Intégration de la GUI Améliorée
🎯 Objectif
Ce guide explique comment intégrer la nouvelle GUI améliorée dans votre application GeniusIA v2.
✅ Composants Disponibles
Composants Principaux
- ImprovedGUI : Interface principale avec LogsPanel et statistiques
- HumanLogger : Générateur de messages lisibles
- GUISignals : Système de signaux Qt pour communication
- InteractiveDialog : Dialogues avec timeout
- OrchestratorGUIBridge : Pont Orchestrator ↔ GUI
Modèles de Données
- GUIState : État de la GUI
- LogMessage : Messages de log
🚀 Méthode 1 : Intégration Automatique (Recommandée)
Utilisation Simple
from PyQt5.QtWidgets import QApplication
from geniusia2.core import Orchestrator
from geniusia2.gui import setup_gui_for_orchestrator
# Créer l'application Qt
app = QApplication(sys.argv)
# Créer l'Orchestrator
orchestrator = Orchestrator()
# Configurer la GUI automatiquement
bridge = setup_gui_for_orchestrator(orchestrator)
bridge.show()
# Maintenant l'orchestrator peut logger vers la GUI
orchestrator.log_to_gui("👀", "Système démarré", "success")
orchestrator.update_gui_stats(actions_count=0, patterns_count=0)
# Lancer l'application
sys.exit(app.exec_())
Avantages
- ✅ Configuration automatique
- ✅ Connexion bidirectionnelle Orchestrator ↔ GUI
- ✅ Méthodes helper ajoutées à l'Orchestrator
- ✅ Gestion des signaux automatique
🔧 Méthode 2 : Intégration Manuelle
Étape 1 : Créer la GUI
from PyQt5.QtWidgets import QApplication
from geniusia2.gui import ImprovedGUI
app = QApplication(sys.argv)
gui = ImprovedGUI(orchestrator)
gui.show()
Étape 2 : Connecter les Signaux
from geniusia2.gui import add_gui_logging_to_orchestrator
# Ajouter le logging GUI à l'orchestrator
add_gui_logging_to_orchestrator(orchestrator, gui.signals)
# Connecter les boutons de contrôle
gui.start_requested.connect(orchestrator.start)
gui.stop_requested.connect(orchestrator.stop)
gui.pause_requested.connect(orchestrator.pause)
Étape 3 : Utiliser dans l'Orchestrator
class Orchestrator:
def on_action_observed(self, action):
# Logger vers la GUI
self.log_to_gui("👀", f"Action dans {action.window}", "info")
# Mettre à jour les stats
self.update_gui_stats(
actions_count=self.actions_count,
patterns_count=self.patterns_count,
workflows_count=self.workflows_count
)
def on_pattern_detected(self, pattern):
self.log_to_gui("🎯", "Pattern détecté !", "success")
def on_mode_change(self, new_mode):
self.change_mode_gui(new_mode)
self.log_to_gui("✅", f"Mode {new_mode} activé", "success")
📝 Méthodes Disponibles dans l'Orchestrator
Après l'intégration, ces méthodes sont disponibles :
log_to_gui(emoji, message, level)
# Envoyer un log à la GUI
orchestrator.log_to_gui("👀", "Message", "info")
orchestrator.log_to_gui("✅", "Succès", "success")
orchestrator.log_to_gui("⚠️", "Attention", "warning")
orchestrator.log_to_gui("❌", "Erreur", "error")
update_gui_stats(**stats)
# Mettre à jour les statistiques
orchestrator.update_gui_stats(
actions_count=12,
patterns_count=2,
workflows_count=1,
finetuning_status='collecting',
finetuning_progress=8
)
change_mode_gui(mode)
# Changer le mode affiché
orchestrator.change_mode_gui("shadow") # 👀 Observation
orchestrator.change_mode_gui("assist") # 💡 Suggestions
orchestrator.change_mode_gui("copilot") # 🤝 Copilote
orchestrator.change_mode_gui("auto") # 🤖 Autonome
💬 Utiliser les Dialogues Interactifs
Dialogue Simple
from geniusia2.gui import InteractiveDialog
def on_accept():
print("Utilisateur a accepté")
orchestrator.change_mode("assist")
def on_reject():
print("Utilisateur a refusé")
# Afficher un dialogue
dialog = InteractiveDialog.show_dialog(
"J'ai une idée !",
"Voulez-vous que je vous suggère des actions ?",
on_accept,
on_reject,
timeout_seconds=10
)
Dialogue via Signaux
# Utiliser le signal show_dialog
orchestrator.gui_signals.emit_dialog(
"Confirmation",
"Voulez-vous continuer ?",
on_accept,
on_reject
)
📊 Exemples d'Utilisation
Exemple 1 : Observer une Action
def on_action_observed(self, action):
# Incrémenter le compteur
self.actions_count += 1
# Logger
message = self.human_logger.log_observation(
action.type,
action.window
)
self.log_to_gui("👀", message, "info")
# Mettre à jour les stats
self.update_gui_stats(actions_count=self.actions_count)
Exemple 2 : Détecter un Pattern
def on_pattern_detected(self, pattern):
# Incrémenter le compteur
self.patterns_count += 1
# Logger
message = self.human_logger.log_pattern_detected(
pattern.repetitions,
pattern.task_name
)
self.log_to_gui("🎯", message, "success")
# Mettre à jour les stats
self.update_gui_stats(
actions_count=self.actions_count,
patterns_count=self.patterns_count
)
# Demander confirmation pour changer de mode
def switch_to_assist():
self.change_mode("assist")
self.change_mode_gui("assist")
self.log_to_gui("✅", "Mode Suggestions activé", "success")
InteractiveDialog.show_dialog(
"Pattern détecté !",
f"J'ai remarqué que vous faites souvent:\n\"{pattern.task_name}\"\n\n"
"Voulez-vous que je vous suggère cette action ?",
switch_to_assist,
lambda: None,
timeout_seconds=10
)
Exemple 3 : Fine-tuning
def on_finetuning_start(self, num_examples):
message = self.human_logger.log_finetuning_started(num_examples)
self.log_to_gui("🧠", message, "info")
self.update_gui_stats(
finetuning_status='training',
finetuning_progress=None
)
def on_finetuning_complete(self, duration):
message = self.human_logger.log_finetuning_completed(duration)
self.log_to_gui("✅", message, "success")
self.update_gui_stats(
finetuning_status='completed',
finetuning_progress=None
)
Exemple 4 : Gestion d'Erreurs
def on_error(self, error_type, context=None):
message = self.human_logger.log_error(error_type, context)
self.log_to_gui("❌", message, "error")
🔄 Modifier main.py
Avant (MinimalGUI)
from geniusia2.gui import MinimalGUI
gui = MinimalGUI(orchestrator)
gui.show()
Après (ImprovedGUI)
from geniusia2.gui import setup_gui_for_orchestrator
bridge = setup_gui_for_orchestrator(orchestrator)
bridge.show()
🧪 Tester l'Intégration
Test Simple
# test_integration_gui.py
from PyQt5.QtWidgets import QApplication
from PyQt5.QtCore import QTimer
import sys
from geniusia2.core import Orchestrator
from geniusia2.gui import setup_gui_for_orchestrator
app = QApplication(sys.argv)
# Créer et configurer
orchestrator = Orchestrator()
bridge = setup_gui_for_orchestrator(orchestrator)
bridge.show()
# Tester après 1 seconde
def test():
orchestrator.log_to_gui("👀", "Test de log", "info")
orchestrator.update_gui_stats(actions_count=5)
orchestrator.change_mode_gui("assist")
QTimer.singleShot(1000, test)
sys.exit(app.exec_())
📋 Checklist d'Intégration
- Importer
setup_gui_for_orchestrator - Créer l'application Qt
- Configurer le bridge
- Afficher la GUI
- Tester
log_to_gui() - Tester
update_gui_stats() - Tester
change_mode_gui() - Tester les boutons de contrôle
- Tester le system tray
- Tester les dialogues interactifs
🐛 Dépannage
La GUI ne s'affiche pas
# Vérifier que l'application Qt est créée
app = QApplication(sys.argv)
# ... créer la GUI ...
sys.exit(app.exec_()) # Important !
Les logs n'apparaissent pas
# Vérifier que le bridge est configuré
bridge = setup_gui_for_orchestrator(orchestrator)
# Vérifier que la méthode existe
if hasattr(orchestrator, 'log_to_gui'):
orchestrator.log_to_gui("✅", "Test", "info")
Les statistiques ne se mettent pas à jour
# Utiliser un dictionnaire complet
orchestrator.update_gui_stats(
actions_count=0,
patterns_count=0,
workflows_count=0
)
📚 Ressources
- test_improved_gui.py : Exemple complet avec simulation
- GUI_AMELIOREE_PRETE.md : Guide détaillé de la GUI
- RESUME_GUI_COMPLETE.md : Résumé des fonctionnalités
✨ Conseils
- Utilisez HumanLogger pour générer des messages lisibles
- Mettez à jour les stats régulièrement pour une GUI réactive
- Utilisez les dialogues pour les confirmations importantes
- Testez le system tray sur Ubuntu
- Gérez les erreurs avec des messages clairs
Bonne intégration ! 🚀