256 lines
6.6 KiB
Markdown
256 lines
6.6 KiB
Markdown
# 📝 Ajouter des Logs dans l'Orchestrator
|
|
|
|
## 🎯 Problème
|
|
|
|
La GUI est connectée mais ne reçoit pas d'informations car l'Orchestrator n'envoie pas encore de logs.
|
|
|
|
## ✅ Solution
|
|
|
|
Ajouter des appels `log_to_gui()` et `update_gui_stats()` dans l'Orchestrator.
|
|
|
|
## 📍 Où Ajouter les Logs
|
|
|
|
### 1. Dans `orchestrator.py` - Méthode `run()`
|
|
|
|
Quand l'observation démarre :
|
|
|
|
```python
|
|
def run(self):
|
|
"""Boucle cognitive principale."""
|
|
self.running = True
|
|
|
|
# LOG: Démarrage
|
|
if hasattr(self, 'log_to_gui'):
|
|
self.log_to_gui("👀", "Observation démarrée", "success")
|
|
|
|
while self.running:
|
|
# ... votre code ...
|
|
```
|
|
|
|
### 2. Quand une Action est Observée
|
|
|
|
```python
|
|
def on_action_observed(self, action):
|
|
"""Appelé quand une action est observée."""
|
|
# Votre code existant...
|
|
|
|
# LOG: Action observée
|
|
if hasattr(self, 'log_to_gui'):
|
|
self.log_to_gui("👀", f"Action dans {action.window}", "info")
|
|
self.update_gui_stats(actions_count=self.actions_count)
|
|
```
|
|
|
|
### 3. Quand un Pattern est Détecté
|
|
|
|
```python
|
|
def on_pattern_detected(self, pattern):
|
|
"""Appelé quand un pattern est détecté."""
|
|
# Votre code existant...
|
|
|
|
# LOG: Pattern détecté
|
|
if hasattr(self, 'log_to_gui'):
|
|
message = self.human_logger.log_pattern_detected(
|
|
pattern.repetitions,
|
|
pattern.task_name
|
|
)
|
|
self.log_to_gui("🎯", message, "success")
|
|
self.update_gui_stats(
|
|
actions_count=self.actions_count,
|
|
patterns_count=self.patterns_count
|
|
)
|
|
```
|
|
|
|
### 4. Quand un Workflow est Appris
|
|
|
|
```python
|
|
def on_workflow_learned(self, workflow):
|
|
"""Appelé quand un workflow est appris."""
|
|
# Votre code existant...
|
|
|
|
# LOG: Workflow appris
|
|
if hasattr(self, 'log_to_gui'):
|
|
message = self.human_logger.log_workflow_learned(
|
|
workflow.name,
|
|
workflow.observation_count
|
|
)
|
|
self.log_to_gui("📚", message, "info")
|
|
self.update_gui_stats(
|
|
actions_count=self.actions_count,
|
|
patterns_count=self.patterns_count,
|
|
workflows_count=self.workflows_count
|
|
)
|
|
```
|
|
|
|
### 5. Quand le Mode Change
|
|
|
|
```python
|
|
def change_mode(self, new_mode):
|
|
"""Change le mode opérationnel."""
|
|
old_mode = self.mode
|
|
self.mode = new_mode
|
|
|
|
# LOG: Changement de mode
|
|
if hasattr(self, 'log_to_gui'):
|
|
message = self.human_logger.log_mode_change(old_mode, new_mode)
|
|
self.change_mode_gui(new_mode)
|
|
self.log_to_gui("✅", message, "success")
|
|
```
|
|
|
|
### 6. Quand une Erreur Survient
|
|
|
|
```python
|
|
def on_error(self, error_type, context=None):
|
|
"""Appelé quand une erreur survient."""
|
|
# Votre code existant...
|
|
|
|
# LOG: Erreur
|
|
if hasattr(self, 'log_to_gui'):
|
|
message = self.human_logger.log_error(error_type, context)
|
|
self.log_to_gui("❌", message, "error")
|
|
```
|
|
|
|
### 7. Fine-tuning
|
|
|
|
```python
|
|
def on_finetuning_start(self, num_examples):
|
|
"""Appelé au début du fine-tuning."""
|
|
if hasattr(self, 'log_to_gui'):
|
|
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):
|
|
"""Appelé à la fin du fine-tuning."""
|
|
if hasattr(self, 'log_to_gui'):
|
|
message = self.human_logger.log_finetuning_completed(duration)
|
|
self.log_to_gui("✅", message, "success")
|
|
self.update_gui_stats(
|
|
finetuning_status='completed',
|
|
finetuning_progress=None
|
|
)
|
|
```
|
|
|
|
## 🔍 Vérifier que les Méthodes Existent
|
|
|
|
Toujours vérifier avec `hasattr()` avant d'appeler :
|
|
|
|
```python
|
|
if hasattr(self, 'log_to_gui'):
|
|
self.log_to_gui("👀", "Message", "info")
|
|
|
|
if hasattr(self, 'update_gui_stats'):
|
|
self.update_gui_stats(actions_count=12)
|
|
|
|
if hasattr(self, 'change_mode_gui'):
|
|
self.change_mode_gui("assist")
|
|
```
|
|
|
|
## 📊 Niveaux de Log
|
|
|
|
- **"info"** : Information normale (gris)
|
|
- **"success"** : Succès, événement positif (vert)
|
|
- **"warning"** : Avertissement (orange)
|
|
- **"error"** : Erreur (rouge)
|
|
|
|
## 🎨 Emojis Recommandés
|
|
|
|
- 👀 : Observation
|
|
- 🎯 : Pattern détecté
|
|
- 📚 : Workflow appris
|
|
- ✅ : Succès, validation
|
|
- 💡 : Suggestion
|
|
- 🧠 : Fine-tuning, apprentissage
|
|
- ⚠️ : Avertissement
|
|
- ❌ : Erreur
|
|
- 🚀 : Démarrage
|
|
- ⏸ : Pause
|
|
- ⏹ : Arrêt
|
|
|
|
## 🧪 Tester
|
|
|
|
Après avoir ajouté les logs, relancez :
|
|
|
|
```bash
|
|
./geniusia2/run.sh
|
|
```
|
|
|
|
Vous devriez voir :
|
|
- ✅ Logs qui s'affichent dans la GUI
|
|
- ✅ Statistiques qui se mettent à jour
|
|
- ✅ Mode qui change
|
|
|
|
## 📝 Exemple Complet
|
|
|
|
Voici un exemple complet d'intégration dans une méthode :
|
|
|
|
```python
|
|
def process_action(self, action):
|
|
"""Traite une action observée."""
|
|
try:
|
|
# 1. Incrémenter le compteur
|
|
self.actions_count += 1
|
|
|
|
# 2. Logger vers la GUI
|
|
if hasattr(self, 'log_to_gui'):
|
|
self.log_to_gui("👀", f"Action dans {action.window}", "info")
|
|
self.update_gui_stats(actions_count=self.actions_count)
|
|
|
|
# 3. Traiter l'action
|
|
result = self._process_action_internal(action)
|
|
|
|
# 4. Si pattern détecté
|
|
if result.pattern_detected:
|
|
if hasattr(self, 'log_to_gui'):
|
|
self.log_to_gui("🎯", "Pattern détecté !", "success")
|
|
self.update_gui_stats(
|
|
actions_count=self.actions_count,
|
|
patterns_count=self.patterns_count
|
|
)
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
# 5. En cas d'erreur
|
|
if hasattr(self, 'log_to_gui'):
|
|
self.log_to_gui("❌", f"Erreur: {str(e)}", "error")
|
|
raise
|
|
```
|
|
|
|
## 🎯 Priorités
|
|
|
|
Pour avoir une GUI fonctionnelle rapidement, ajoutez au minimum :
|
|
|
|
1. **Log au démarrage** (dans `run()`)
|
|
2. **Log quand action observée** (dans la boucle principale)
|
|
3. **Mise à jour du compteur d'actions**
|
|
|
|
Ensuite, ajoutez progressivement :
|
|
4. Patterns détectés
|
|
5. Workflows appris
|
|
6. Changements de mode
|
|
7. Fine-tuning
|
|
8. Erreurs
|
|
|
|
## 💡 Astuce
|
|
|
|
Pour tester rapidement, ajoutez un log de test au début de `run()` :
|
|
|
|
```python
|
|
def run(self):
|
|
# Test de connexion GUI
|
|
if hasattr(self, 'log_to_gui'):
|
|
self.log_to_gui("✅", "Orchestrator connecté à la GUI", "success")
|
|
print("✅ GUI connectée et fonctionnelle")
|
|
else:
|
|
print("⚠️ GUI non connectée")
|
|
|
|
# Votre code normal...
|
|
```
|
|
|
|
---
|
|
|
|
**Une fois les logs ajoutés, la GUI sera pleinement fonctionnelle ! 🚀**
|