363 lines
9.5 KiB
Markdown
363 lines
9.5 KiB
Markdown
# 🔄 Implémentation de la Détection de Workflows
|
|
|
|
**Date** : 19 Novembre 2025
|
|
**Objectif** : Implémenter la détection de workflows complets au lieu de micro-patterns
|
|
|
|
## ✅ Ce qui a été fait
|
|
|
|
### 1. SessionManager (`geniusia2/core/session_manager.py`)
|
|
|
|
**Rôle** : Segmenter les actions en sessions basées sur le temps et le contexte.
|
|
|
|
**Fonctionnalités** :
|
|
- ✅ Détection automatique de début/fin de session
|
|
- ✅ Timeout configurable (5 minutes par défaut)
|
|
- ✅ Détection de changement de fenêtre
|
|
- ✅ Historique des sessions
|
|
- ✅ Callback `on_session_completed`
|
|
- ✅ Statistiques (durée moyenne, actions par session)
|
|
|
|
**Classe `Session`** :
|
|
```python
|
|
@dataclass
|
|
class Session:
|
|
session_id: str
|
|
start_time: datetime
|
|
end_time: Optional[datetime]
|
|
actions: List[Dict[str, Any]]
|
|
window: Optional[str]
|
|
```
|
|
|
|
**Méthodes principales** :
|
|
- `add_action(action)` : Ajoute une action à la session courante
|
|
- `should_start_new_session(action)` : Détermine si nouvelle session nécessaire
|
|
- `finalize_current_session()` : Finalise la session courante
|
|
- `get_recent_sessions(n)` : Retourne les N sessions récentes
|
|
- `get_stats()` : Statistiques des sessions
|
|
|
|
### 2. WorkflowDetector (`geniusia2/core/workflow_detector.py`)
|
|
|
|
**Rôle** : Détecter les workflows répétés en analysant les sessions.
|
|
|
|
**Fonctionnalités** :
|
|
- ✅ Analyse de sessions pour détecter des similarités
|
|
- ✅ Seuil de répétition configurable (3 par défaut)
|
|
- ✅ Seuil de similarité configurable (75% par défaut)
|
|
- ✅ Création de workflows à partir de sessions similaires
|
|
- ✅ Callback `on_workflow_detected`
|
|
- ✅ Mise à jour des workflows existants
|
|
|
|
**Classe `Workflow`** :
|
|
```python
|
|
@dataclass
|
|
class Workflow:
|
|
workflow_id: str
|
|
name: str
|
|
steps: List[WorkflowStep]
|
|
repetitions: int
|
|
confidence: float
|
|
last_seen: datetime
|
|
```
|
|
|
|
**Classe `WorkflowStep`** :
|
|
```python
|
|
@dataclass
|
|
class WorkflowStep:
|
|
step_id: int
|
|
action_type: str
|
|
target_description: str
|
|
position: tuple
|
|
window: str
|
|
embedding: Optional[np.ndarray]
|
|
screenshot: Optional[np.ndarray]
|
|
```
|
|
|
|
**Méthodes principales** :
|
|
- `analyze_sessions(sessions)` : Analyse les sessions pour détecter des workflows
|
|
- `_calculate_session_similarity(sessions)` : Calcule la similarité entre sessions
|
|
- `_compare_two_sessions(s1, s2)` : Compare deux sessions
|
|
- `_create_workflow_from_sessions(sessions)` : Crée un workflow
|
|
- `get_workflows()` : Retourne tous les workflows détectés
|
|
- `get_stats()` : Statistiques des workflows
|
|
|
|
### 3. Intégration dans EventCapture
|
|
|
|
**Modifications dans `geniusia2/core/event_capture.py`** :
|
|
|
|
```python
|
|
# Initialisation
|
|
self.session_manager = SessionManager(logger, self.config)
|
|
self.workflow_detector = WorkflowDetector(logger, self.config)
|
|
|
|
# Connexion des callbacks
|
|
self.session_manager.on_session_completed = self._on_session_completed
|
|
self.workflow_detector.on_workflow_detected = self._on_workflow_detected
|
|
```
|
|
|
|
**Nouveaux callbacks** :
|
|
- `_on_session_completed(session)` : Appelé quand une session est terminée
|
|
- `_on_workflow_detected(workflow)` : Appelé quand un workflow est détecté
|
|
|
|
**Nouvelles méthodes publiques** :
|
|
- `capture_event(action)` : Capture un événement manuellement (pour tests)
|
|
- `get_workflows()` : Retourne les workflows détectés
|
|
- `get_sessions(count)` : Retourne les sessions récentes
|
|
- `get_workflow_stats()` : Statistiques complètes
|
|
- `force_finalize_session()` : Force la finalisation de la session
|
|
|
|
## 🔄 Flux de Détection
|
|
|
|
```
|
|
1. Utilisateur effectue des actions
|
|
↓
|
|
2. EventCapture capture les événements
|
|
↓
|
|
3. SessionManager segmente en sessions
|
|
├─ Timeout (5 min) → Nouvelle session
|
|
├─ Changement fenêtre → Nouvelle session
|
|
└─ Session terminée → Callback
|
|
↓
|
|
4. WorkflowDetector analyse les sessions
|
|
├─ Compare les 3+ dernières sessions
|
|
├─ Calcule la similarité (75% minimum)
|
|
└─ Si similaires → Workflow détecté
|
|
↓
|
|
5. Workflow créé/mis à jour
|
|
├─ Génération d'un nom descriptif
|
|
├─ Création des étapes (WorkflowStep)
|
|
└─ Callback → Notification
|
|
```
|
|
|
|
## 📊 Algorithme de Détection
|
|
|
|
### Similarité entre Sessions
|
|
|
|
```python
|
|
def _compare_two_sessions(session1, session2):
|
|
# 1. Vérifier la longueur (tolérance de 2 actions)
|
|
if abs(len(actions1) - len(actions2)) > 2:
|
|
return 0.0
|
|
|
|
# 2. Comparer action par action
|
|
for i in range(min_len):
|
|
# Type d'action identique → +1 point
|
|
if action1.type == action2.type:
|
|
matches += 1
|
|
|
|
# Même fenêtre → +0.5 point bonus
|
|
if action1.window == action2.window:
|
|
matches += 0.5
|
|
|
|
# 3. Score normalisé (0-1)
|
|
return matches / (min_len * 1.5)
|
|
```
|
|
|
|
### Détection de Workflow
|
|
|
|
```python
|
|
def analyze_sessions(sessions):
|
|
# 1. Prendre N sessions consécutives (N = min_repetitions)
|
|
for i in range(len(sessions) - N + 1):
|
|
session_group = sessions[i:i + N]
|
|
|
|
# 2. Calculer similarité moyenne
|
|
similarity = calculate_session_similarity(session_group)
|
|
|
|
# 3. Si similarité >= 75% → Workflow !
|
|
if similarity >= 0.75:
|
|
workflow = create_workflow_from_sessions(session_group)
|
|
|
|
# 4. Vérifier si workflow existe déjà
|
|
existing = find_existing_workflow(workflow)
|
|
|
|
if existing:
|
|
# Mettre à jour
|
|
existing.repetitions += 1
|
|
existing.confidence += 0.05
|
|
else:
|
|
# Nouveau workflow
|
|
workflows.append(workflow)
|
|
on_workflow_detected(workflow)
|
|
```
|
|
|
|
## 🎯 Configuration
|
|
|
|
Dans `config.py`, ajouter :
|
|
|
|
```python
|
|
"workflow": {
|
|
# Timeout de session (secondes)
|
|
"session_timeout": 300, # 5 minutes
|
|
|
|
# Nombre minimum de répétitions pour détecter un workflow
|
|
"min_repetitions": 3,
|
|
|
|
# Seuil de similarité pour considérer deux sessions comme identiques
|
|
"similarity_threshold": 0.75 # 75%
|
|
}
|
|
```
|
|
|
|
## 🧪 Tests
|
|
|
|
### Test Basique
|
|
|
|
```python
|
|
from core.event_capture import EventCapture
|
|
from core.config import get_config
|
|
|
|
# Initialiser
|
|
config = get_config()
|
|
event_capture = EventCapture(
|
|
logger=logger,
|
|
pattern_threshold=3,
|
|
config=config
|
|
)
|
|
|
|
# Simuler des actions répétées
|
|
for i in range(3):
|
|
# Session 1
|
|
event_capture.capture_event({
|
|
"action_type": "click",
|
|
"position": (100, 50),
|
|
"window": "Desktop",
|
|
"timestamp": datetime.now()
|
|
})
|
|
|
|
event_capture.capture_event({
|
|
"action_type": "type",
|
|
"text": "office",
|
|
"window": "Desktop",
|
|
"timestamp": datetime.now()
|
|
})
|
|
|
|
# Finaliser la session
|
|
event_capture.force_finalize_session()
|
|
|
|
# Vérifier les workflows
|
|
workflows = event_capture.get_workflows()
|
|
print(f"Workflows détectés: {len(workflows)}")
|
|
```
|
|
|
|
### Test Complet
|
|
|
|
Voir `test_workflow_suggestion.py` pour un test complet avec :
|
|
- Création de 3 sessions similaires
|
|
- Détection automatique de workflow
|
|
- Suggestion basée sur le début d'un workflow
|
|
|
|
## 📈 Avantages
|
|
|
|
### Avant (Micro-Patterns)
|
|
- ❌ Détecte seulement les clics répétés
|
|
- ❌ Inutilisable en pratique
|
|
- ❌ Ne correspond pas à l'usage réel
|
|
|
|
### Après (Macro-Workflows)
|
|
- ✅ Détecte les workflows complets
|
|
- ✅ Utilisable en pratique
|
|
- ✅ Correspond à l'usage réel
|
|
- ✅ Vrai RPA Vision !
|
|
|
|
## 🚀 Prochaines Étapes
|
|
|
|
### Court Terme
|
|
1. ✅ ~~Créer SessionManager~~ **Fait !**
|
|
2. ✅ ~~Créer WorkflowDetector~~ **Fait !**
|
|
3. ✅ ~~Intégrer dans EventCapture~~ **Fait !**
|
|
4. 🔄 **Tester avec workflow réel** (OnlyOffice)
|
|
5. 🔄 **Ajuster les seuils** si nécessaire
|
|
|
|
### Moyen Terme
|
|
6. Intégrer dans SuggestionManager
|
|
7. Afficher suggestions de workflow dans la GUI
|
|
8. Permettre l'exécution de workflows complets
|
|
|
|
### Long Terme
|
|
9. Apprentissage des variations de workflows
|
|
10. Workflows conditionnels (if/else)
|
|
11. Workflows avec boucles
|
|
|
|
## 📝 Exemple Concret
|
|
|
|
### Scénario : Ouvrir OnlyOffice
|
|
|
|
**Jour 1 - 10h00** :
|
|
```
|
|
Session 1:
|
|
1. Clic sur lanceur (100, 50)
|
|
2. Type "office"
|
|
3. Clic sur OnlyOffice (150, 100)
|
|
4. Clic "Nouveau document" (200, 150)
|
|
```
|
|
|
|
**Jour 2 - 14h30** :
|
|
```
|
|
Session 2:
|
|
1. Clic sur lanceur (100, 50)
|
|
2. Type "office"
|
|
3. Clic sur OnlyOffice (150, 100)
|
|
4. Clic "Nouveau document" (200, 150)
|
|
```
|
|
|
|
**Jour 3 - 16h00** :
|
|
```
|
|
Session 3:
|
|
1. Clic sur lanceur (100, 50)
|
|
2. Type "office"
|
|
3. Clic sur OnlyOffice (150, 100)
|
|
4. Clic "Nouveau document" (200, 150)
|
|
```
|
|
|
|
**Résultat** :
|
|
```
|
|
🎉 Workflow détecté !
|
|
Nom: "Click → Type → Click (+ 1 étapes)"
|
|
Répétitions: 3x
|
|
Confiance: 80%
|
|
Étapes: 4
|
|
```
|
|
|
|
**Jour 4 - Suggestion** :
|
|
```
|
|
Utilisateur fait:
|
|
1. Clic sur lanceur
|
|
2. Type "office"
|
|
|
|
Système détecte:
|
|
"Tu es au début du workflow 'Ouvrir OnlyOffice'"
|
|
|
|
Suggestion:
|
|
"Je peux continuer ce workflow pour toi ?"
|
|
[Oui] [Non] [Corriger]
|
|
```
|
|
|
|
## ✅ Checklist d'Implémentation
|
|
|
|
- [x] Créer `SessionManager`
|
|
- [x] Créer `WorkflowDetector`
|
|
- [x] Ajouter imports dans `EventCapture`
|
|
- [x] Connecter les callbacks
|
|
- [x] Ajouter méthodes publiques
|
|
- [x] Corriger les appels de méthodes
|
|
- [x] Ajouter `capture_event()` pour tests
|
|
- [ ] Tester avec workflow réel
|
|
- [ ] Ajuster les seuils
|
|
- [ ] Intégrer dans SuggestionManager
|
|
- [ ] Ajouter GUI pour workflows
|
|
|
|
## 🎊 Conclusion
|
|
|
|
Le système de détection de workflows est maintenant **implémenté** !
|
|
|
|
**Capacités** :
|
|
- ✅ Segmentation en sessions
|
|
- ✅ Détection de workflows répétés
|
|
- ✅ Callbacks pour notifications
|
|
- ✅ Statistiques complètes
|
|
|
|
**Prêt pour les tests ! 🚀**
|
|
|
|
---
|
|
|
|
**Implémenté le 19 Novembre 2025**
|