370 lines
9.0 KiB
Markdown
370 lines
9.0 KiB
Markdown
# 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
|
|
|
|
```python
|
|
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
|
|
|
|
```python
|
|
from PyQt5.QtWidgets import QApplication
|
|
from geniusia2.gui import ImprovedGUI
|
|
|
|
app = QApplication(sys.argv)
|
|
gui = ImprovedGUI(orchestrator)
|
|
gui.show()
|
|
```
|
|
|
|
### Étape 2 : Connecter les Signaux
|
|
|
|
```python
|
|
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
|
|
|
|
```python
|
|
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)
|
|
```python
|
|
# 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)
|
|
```python
|
|
# 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)
|
|
```python
|
|
# 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
|
|
|
|
```python
|
|
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
|
|
|
|
```python
|
|
# 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
|
|
|
|
```python
|
|
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
|
|
|
|
```python
|
|
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
|
|
|
|
```python
|
|
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
|
|
|
|
```python
|
|
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)
|
|
|
|
```python
|
|
from geniusia2.gui import MinimalGUI
|
|
|
|
gui = MinimalGUI(orchestrator)
|
|
gui.show()
|
|
```
|
|
|
|
### Après (ImprovedGUI)
|
|
|
|
```python
|
|
from geniusia2.gui import setup_gui_for_orchestrator
|
|
|
|
bridge = setup_gui_for_orchestrator(orchestrator)
|
|
bridge.show()
|
|
```
|
|
|
|
## 🧪 Tester l'Intégration
|
|
|
|
### Test Simple
|
|
|
|
```python
|
|
# 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
|
|
```python
|
|
# 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
|
|
```python
|
|
# 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
|
|
```python
|
|
# 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
|
|
|
|
1. **Utilisez HumanLogger** pour générer des messages lisibles
|
|
2. **Mettez à jour les stats régulièrement** pour une GUI réactive
|
|
3. **Utilisez les dialogues** pour les confirmations importantes
|
|
4. **Testez le system tray** sur Ubuntu
|
|
5. **Gérez les erreurs** avec des messages clairs
|
|
|
|
---
|
|
|
|
**Bonne intégration ! 🚀**
|