474 lines
14 KiB
Python
Executable File
474 lines
14 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
"""
|
||
Test du Mode Assisté avec détection de workflows
|
||
Simule un utilisateur qui répète des actions et reçoit des suggestions
|
||
"""
|
||
|
||
import sys
|
||
import time
|
||
import numpy as np
|
||
from pathlib import Path
|
||
from datetime import datetime, timedelta
|
||
|
||
sys.path.insert(0, str(Path(__file__).parent / "geniusia2"))
|
||
|
||
from core.logger import Logger
|
||
from core.config import get_config
|
||
from core.event_capture import EventCapture
|
||
from core.learning_manager import LearningManager
|
||
from core.embeddings_manager import EmbeddingsManager
|
||
from core.suggestion_manager import SuggestionManager
|
||
|
||
|
||
def create_mock_learning_manager():
|
||
"""Crée un mock du LearningManager pour les tests"""
|
||
class MockEmbeddingsManager:
|
||
def search_similar(self, embedding, k=3):
|
||
return [] # Pas de résultats pour forcer les suggestions de workflow
|
||
|
||
class MockLearningManager:
|
||
def __init__(self):
|
||
self.embeddings_manager = MockEmbeddingsManager()
|
||
|
||
def load_task(self, task_id):
|
||
return None
|
||
|
||
def confirm_action(self, data):
|
||
pass
|
||
|
||
return MockLearningManager()
|
||
|
||
|
||
def simulate_workflow_actions(event_capture, workflow_name, base_time):
|
||
"""Simule une séquence d'actions formant un workflow"""
|
||
|
||
workflows = {
|
||
"onlyoffice": [
|
||
{
|
||
"type": "mouse_click",
|
||
"action_type": "click",
|
||
"x": 100,
|
||
"y": 50,
|
||
"position": (100, 50),
|
||
"window": "Desktop",
|
||
"description": "Ouvrir lanceur"
|
||
},
|
||
{
|
||
"type": "key_press",
|
||
"action_type": "type",
|
||
"key": "office",
|
||
"text": "office",
|
||
"window": "Desktop",
|
||
"description": "Chercher OnlyOffice"
|
||
},
|
||
{
|
||
"type": "mouse_click",
|
||
"action_type": "click",
|
||
"x": 150,
|
||
"y": 100,
|
||
"position": (150, 100),
|
||
"window": "Desktop",
|
||
"description": "Lancer OnlyOffice"
|
||
},
|
||
{
|
||
"type": "mouse_click",
|
||
"action_type": "click",
|
||
"x": 200,
|
||
"y": 150,
|
||
"position": (200, 150),
|
||
"window": "OnlyOffice",
|
||
"description": "Nouveau document"
|
||
},
|
||
{
|
||
"type": "key_press",
|
||
"action_type": "type",
|
||
"key": "Bonjour",
|
||
"text": "Bonjour",
|
||
"window": "OnlyOffice",
|
||
"description": "Taper du texte"
|
||
}
|
||
],
|
||
"firefox": [
|
||
{
|
||
"type": "mouse_click",
|
||
"action_type": "click",
|
||
"x": 50,
|
||
"y": 50,
|
||
"position": (50, 50),
|
||
"window": "Firefox",
|
||
"description": "Ouvrir Firefox"
|
||
},
|
||
{
|
||
"type": "key_press",
|
||
"action_type": "type",
|
||
"key": "google.com",
|
||
"text": "google.com",
|
||
"window": "Firefox",
|
||
"description": "Aller sur Google"
|
||
},
|
||
{
|
||
"type": "mouse_click",
|
||
"action_type": "click",
|
||
"x": 300,
|
||
"y": 200,
|
||
"position": (300, 200),
|
||
"window": "Firefox",
|
||
"description": "Cliquer recherche"
|
||
}
|
||
]
|
||
}
|
||
|
||
actions = workflows.get(workflow_name, [])
|
||
|
||
for i, action_template in enumerate(actions):
|
||
action = {
|
||
**action_template,
|
||
"timestamp": (base_time + timedelta(seconds=i*2)).isoformat()
|
||
}
|
||
event_capture.capture_event(action)
|
||
|
||
return len(actions)
|
||
|
||
|
||
def test_workflow_learning():
|
||
"""Test 1: Apprentissage de workflows"""
|
||
print("\n" + "="*60)
|
||
print("🧪 TEST 1: Apprentissage de workflows")
|
||
print("="*60)
|
||
|
||
logger = Logger()
|
||
config = get_config()
|
||
|
||
event_capture = EventCapture(
|
||
logger=logger,
|
||
max_history=1000,
|
||
pattern_threshold=3,
|
||
config=config
|
||
)
|
||
|
||
print("\n📋 Simulation de 3 répétitions du workflow OnlyOffice...")
|
||
|
||
for i in range(3):
|
||
base_time = datetime.now() - timedelta(hours=3-i)
|
||
actions_count = simulate_workflow_actions(event_capture, "onlyoffice", base_time)
|
||
event_capture.force_finalize_session()
|
||
print(f" ✅ Répétition {i+1}: {actions_count} actions")
|
||
|
||
# Vérifier les workflows détectés
|
||
workflows = event_capture.get_workflows()
|
||
|
||
print(f"\n📊 Résultats:")
|
||
print(f" Sessions: {len(event_capture.get_sessions())}")
|
||
print(f" Workflows détectés: {len(workflows)}")
|
||
|
||
if workflows:
|
||
for workflow in workflows:
|
||
print(f"\n 🎉 Workflow appris:")
|
||
print(f" Nom: {workflow.name}")
|
||
print(f" Étapes: {len(workflow.steps)}")
|
||
print(f" Répétitions: {workflow.repetitions}")
|
||
print(f" Confiance: {workflow.confidence:.2%}")
|
||
|
||
return True, workflows[0]
|
||
else:
|
||
print(f"\n ⚠️ Aucun workflow détecté")
|
||
return False, None
|
||
|
||
|
||
def test_workflow_suggestion(learned_workflow):
|
||
"""Test 2: Suggestion de workflow en cours"""
|
||
print("\n" + "="*60)
|
||
print("🧪 TEST 2: Suggestion de workflow")
|
||
print("="*60)
|
||
|
||
logger = Logger()
|
||
config = get_config()
|
||
|
||
# Créer les composants
|
||
event_capture = EventCapture(
|
||
logger=logger,
|
||
max_history=1000,
|
||
pattern_threshold=3,
|
||
config=config
|
||
)
|
||
|
||
# Simuler que le workflow a été appris
|
||
event_capture.workflow_detector.workflows.append(learned_workflow)
|
||
|
||
# Mock du LearningManager
|
||
class MockLearningManager:
|
||
def __init__(self):
|
||
pass # Mock
|
||
|
||
def load_task(self, task_id):
|
||
return None
|
||
|
||
def confirm_action(self, data):
|
||
pass
|
||
|
||
learning_manager = create_mock_learning_manager()
|
||
|
||
suggestion_manager = SuggestionManager(
|
||
learning_manager=learning_manager,
|
||
embeddings_manager=learning_manager.embeddings_manager,
|
||
logger=logger,
|
||
config=config
|
||
)
|
||
|
||
print("\n📋 Simulation du début du workflow...")
|
||
|
||
# Simuler les 2 premières actions du workflow
|
||
base_time = datetime.now()
|
||
|
||
action1 = {
|
||
"type": "mouse_click",
|
||
"action_type": "click",
|
||
"x": 100,
|
||
"y": 50,
|
||
"position": (100, 50),
|
||
"window": "Desktop",
|
||
"timestamp": base_time.isoformat(),
|
||
"description": "Ouvrir lanceur"
|
||
}
|
||
event_capture.capture_event(action1)
|
||
print(f" ✅ Action 1: {action1['description']}")
|
||
|
||
action2 = {
|
||
"type": "key_press",
|
||
"action_type": "type",
|
||
"key": "office",
|
||
"text": "office",
|
||
"window": "Desktop",
|
||
"timestamp": (base_time + timedelta(seconds=2)).isoformat(),
|
||
"description": "Chercher OnlyOffice"
|
||
}
|
||
event_capture.capture_event(action2)
|
||
print(f" ✅ Action 2: {action2['description']}")
|
||
|
||
# Créer le contexte pour la suggestion
|
||
context = {
|
||
"event_capture": event_capture,
|
||
"embedding": np.random.rand(512), # Mock embedding
|
||
"window": "Desktop",
|
||
"timestamp": datetime.now()
|
||
}
|
||
|
||
print(f"\n🔍 Recherche de suggestion...")
|
||
|
||
# Chercher une suggestion
|
||
suggestion = suggestion_manager.find_suggestion(context)
|
||
|
||
if suggestion and suggestion.get("type") == "workflow":
|
||
print(f"\n 🎉 Suggestion de workflow trouvée !")
|
||
print(f" Workflow: {suggestion['workflow_name']}")
|
||
print(f" Étape actuelle: {suggestion['current_step']}/{suggestion['total_steps']}")
|
||
print(f" Prochaine action: {suggestion['next_action']['description']}")
|
||
print(f" Confiance: {suggestion['confidence']:.2%}")
|
||
print(f" Actions restantes: {suggestion['remaining_steps']}")
|
||
|
||
return True
|
||
else:
|
||
print(f"\n ⚠️ Aucune suggestion de workflow")
|
||
if suggestion:
|
||
print(f" Type de suggestion: {suggestion.get('type')}")
|
||
return False
|
||
|
||
|
||
def test_workflow_completion():
|
||
"""Test 3: Complétion d'un workflow avec suggestions"""
|
||
print("\n" + "="*60)
|
||
print("🧪 TEST 3: Complétion de workflow")
|
||
print("="*60)
|
||
|
||
logger = Logger()
|
||
config = get_config()
|
||
|
||
# Augmenter le timeout de session pour éviter la fragmentation
|
||
config["workflow"] = config.get("workflow", {})
|
||
config["workflow"]["session_timeout"] = 600 # 10 minutes
|
||
|
||
event_capture = EventCapture(
|
||
logger=logger,
|
||
max_history=1000,
|
||
pattern_threshold=3,
|
||
config=config
|
||
)
|
||
|
||
# Apprendre un workflow simple
|
||
print("\n📋 Phase 1: Apprentissage (3 répétitions)...")
|
||
|
||
for i in range(3):
|
||
base_time = datetime.now() - timedelta(hours=3-i)
|
||
simulate_workflow_actions(event_capture, "firefox", base_time)
|
||
event_capture.force_finalize_session()
|
||
print(f" ✅ Répétition {i+1}")
|
||
|
||
# Forcer l'analyse des sessions pour détecter les workflows
|
||
sessions = event_capture.get_sessions(10)
|
||
event_capture.workflow_detector.analyze_sessions(sessions)
|
||
|
||
workflows = event_capture.get_workflows()
|
||
|
||
if not workflows:
|
||
print(f"\n ❌ Aucun workflow appris")
|
||
return False
|
||
|
||
print(f" ✅ Workflow appris: {workflows[0].name}")
|
||
|
||
# Mock du LearningManager
|
||
class MockLearningManager:
|
||
def __init__(self):
|
||
pass # Mock
|
||
|
||
def load_task(self, task_id):
|
||
return None
|
||
|
||
def confirm_action(self, data):
|
||
pass
|
||
|
||
learning_manager = create_mock_learning_manager()
|
||
|
||
suggestion_manager = SuggestionManager(
|
||
learning_manager=learning_manager,
|
||
embeddings_manager=learning_manager.embeddings_manager,
|
||
logger=logger,
|
||
config=config
|
||
)
|
||
|
||
# Simuler l'exécution du workflow avec suggestions
|
||
print(f"\n📋 Phase 2: Exécution avec suggestions...")
|
||
|
||
base_time = datetime.now()
|
||
workflow_actions = [
|
||
{
|
||
"type": "mouse_click",
|
||
"action_type": "click",
|
||
"x": 50,
|
||
"y": 50,
|
||
"position": (50, 50),
|
||
"window": "Desktop",
|
||
"description": "Ouvrir Firefox"
|
||
},
|
||
{
|
||
"type": "key_press",
|
||
"action_type": "type",
|
||
"key": "google.com",
|
||
"text": "google.com",
|
||
"window": "Firefox",
|
||
"description": "Aller sur Google"
|
||
}
|
||
]
|
||
|
||
suggestions_received = 0
|
||
|
||
for i, action in enumerate(workflow_actions):
|
||
action["timestamp"] = (base_time + timedelta(seconds=i*2)).isoformat()
|
||
event_capture.capture_event(action)
|
||
print(f"\n Action {i+1}: {action['description']}")
|
||
|
||
# Debug: vérifier la session courante
|
||
if event_capture.session_manager.current_session:
|
||
session = event_capture.session_manager.current_session
|
||
print(f" Session courante: {session.action_count} actions")
|
||
for j, act in enumerate(session.actions):
|
||
print(f" {j+1}. {act.get('action_type')} - {act.get('description')}")
|
||
else:
|
||
print(f" ⚠️ Pas de session courante")
|
||
|
||
# Chercher une suggestion
|
||
context = {
|
||
"event_capture": event_capture,
|
||
"embedding": np.random.rand(512),
|
||
"window": action["window"],
|
||
"timestamp": datetime.now()
|
||
}
|
||
|
||
suggestion = suggestion_manager.find_suggestion(context)
|
||
|
||
if suggestion:
|
||
if suggestion.get("type") == "workflow":
|
||
suggestions_received += 1
|
||
print(f" 💡 Suggestion: {suggestion['next_action']['description']}")
|
||
print(f" 📊 Confiance: {suggestion['confidence']:.2%}")
|
||
else:
|
||
print(f" ℹ️ Suggestion type: {suggestion.get('type')}")
|
||
else:
|
||
print(f" ⚠️ Aucune suggestion trouvée")
|
||
|
||
print(f"\n📊 Résultats:")
|
||
print(f" Actions exécutées: {len(workflow_actions)}")
|
||
print(f" Suggestions reçues: {suggestions_received}")
|
||
|
||
return suggestions_received > 0
|
||
|
||
|
||
def main():
|
||
"""Exécute tous les tests"""
|
||
print("\n" + "="*60)
|
||
print("🚀 TEST MODE ASSISTÉ AVEC WORKFLOWS")
|
||
print("="*60)
|
||
|
||
results = []
|
||
learned_workflow = None
|
||
|
||
try:
|
||
# Test 1: Apprentissage
|
||
success, workflow = test_workflow_learning()
|
||
results.append(("Apprentissage", success))
|
||
learned_workflow = workflow
|
||
except Exception as e:
|
||
print(f"\n❌ ERREUR Test 1: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
results.append(("Apprentissage", False))
|
||
|
||
if learned_workflow:
|
||
try:
|
||
# Test 2: Suggestion
|
||
success = test_workflow_suggestion(learned_workflow)
|
||
results.append(("Suggestion", success))
|
||
except Exception as e:
|
||
print(f"\n❌ ERREUR Test 2: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
results.append(("Suggestion", False))
|
||
else:
|
||
print(f"\n⚠️ Test 2 ignoré (pas de workflow appris)")
|
||
results.append(("Suggestion", False))
|
||
|
||
try:
|
||
# Test 3: Complétion
|
||
success = test_workflow_completion()
|
||
results.append(("Complétion", success))
|
||
except Exception as e:
|
||
print(f"\n❌ ERREUR Test 3: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
results.append(("Complétion", False))
|
||
|
||
# Résumé
|
||
print("\n" + "="*60)
|
||
print("📊 RÉSUMÉ DES TESTS")
|
||
print("="*60)
|
||
|
||
for name, success in results:
|
||
status = "✅" if success else "❌"
|
||
print(f"{status} {name}")
|
||
|
||
total = len(results)
|
||
passed = sum(1 for _, success in results if success)
|
||
|
||
print(f"\n📈 Score: {passed}/{total} tests réussis")
|
||
|
||
if passed == total:
|
||
print("\n🎉 TOUS LES TESTS SONT PASSÉS !")
|
||
print("\n💡 Le Mode Assisté avec workflows fonctionne !")
|
||
return 0
|
||
else:
|
||
print(f"\n⚠️ {total - passed} test(s) échoué(s)")
|
||
return 1
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|