Geniusia_v2/geniusia2/gui/dialogs/README.md

Dialogues et Notifications GUI

Ce module contient les dialogues de correction et les systèmes de notification pour RPA Vision V2.

Composants

1. CorrectionDialog

Dialogue permettant à l'utilisateur de corriger une détection incorrecte en sélectionnant l'élément UI correct.

Fonctionnalités:

• Affichage de la détection incorrecte
• Liste de détections alternatives sélectionnables
• Saisie manuelle de correction
• Double-clic pour sélection rapide

Utilisation:

from geniusia2.gui.dialogs import CorrectionDialog

# Détection incorrecte
incorrect = {
    "label": "annuler_button",
    "confidence": 0.75,
    "bbox": (300, 400, 100, 35),
    "action_type": "click"
}

# Alternatives disponibles
alternatives = [
    {
        "label": "valider_button",
        "confidence": 0.92,
        "bbox": (450, 400, 100, 35),
        "action_type": "click"
    },
    # ... autres alternatives
]

# Afficher le dialogue
correction = CorrectionDialog.show_correction_dialog(
    incorrect,
    alternatives
)

if correction:
    corrected_element = correction['corrected_element']
    method = correction['correction_method']  # "alternative" ou "manual"
    print(f"Correction: {corrected_element['label']} via {method}")

Exigences satisfaites: 2.5, 2.6

2. PostActionNotification

Notification post-action affichant le succès (✔️) ou l'échec (❌) d'une action avec possibilité de retour correctif.

Fonctionnalités:

• Affichage animé en haut à droite
• Timeout automatique de 5 secondes
• Barre de progression visuelle
• Bouton de correction pour les échecs
• Fermeture par clic

Utilisation:

from geniusia2.gui.dialogs import PostActionNotification

# Notification de succès
notification = PostActionNotification.show_success(
    action_type="click",
    target_element="valider_button",
    confidence=0.95
)

# Notification d'échec avec correction
def on_correction(data):
    print(f"Correction demandée pour: {data}")

notification = PostActionNotification.show_failure(
    action_type="click",
    target_element="annuler_button",
    error_message="Élément non trouvé à l'écran",
    confidence=0.65,
    allow_correction=True
)
notification.allow_corrective_feedback(on_correction)

# Écouter les retours
notification.feedback_provided.connect(
    lambda result: print(f"Retour: {result}")
)

Exigences satisfaites: 3.4, 3.5, 3.6

3. TransitionNotification

Notifications pour les transitions de mode et alertes système.

Types de notifications:

• TYPE_AUTOPILOT_PROPOSAL: Proposition de passage en Autopilot
• TYPE_CONFIDENCE_DROP: Alerte de baisse de confiance
• TYPE_WHITELIST_VIOLATION: Violation de liste blanche
• TYPE_UI_CHANGE: Changement d'interface détecté
• TYPE_MODE_TRANSITION: Transition de mode

Utilisation:

from geniusia2.gui.dialogs import TransitionNotification

# Proposition de passage en Autopilot
notification = TransitionNotification.show_autopilot_proposal(
    task_name="Ouvrir Facture",
    observation_count=25,
    concordance_rate=0.97
)
notification.action_taken.connect(
    lambda action: handle_autopilot_decision(action)
)

# Alerte de baisse de confiance
notification = TransitionNotification.show_confidence_drop(
    task_name="Saisie Données",
    confidence_score=0.85,
    threshold=0.90,
    reason="Changements UI détectés"
)

# Violation de liste blanche
notification = TransitionNotification.show_whitelist_violation(
    window_title="Application Non Autorisée",
    action_type="click"
)
notification.action_taken.connect(
    lambda action: handle_whitelist_decision(action)
)

# Changement d'interface
notification = TransitionNotification.show_ui_change(
    task_name="Navigation Menu",
    similarity=0.65
)
notification.action_taken.connect(
    lambda action: handle_ui_change(action)
)

# Transition de mode
notification = TransitionNotification.show_mode_transition(
    task_name="Export Données",
    from_mode="auto",
    to_mode="assist",
    reason="low_confidence"
)

Exigences satisfaites: 3.1, 4.5, 5.4, 6.2, 6.3, 6.5

Intégration avec MinimalGUI

Les dialogues et notifications peuvent être intégrés dans l'interface principale:

from geniusia2.gui.minimal_gui import MinimalGUI
from geniusia2.gui.dialogs import (
    CorrectionDialog,
    PostActionNotification,
    TransitionNotification
)

class EnhancedGUI(MinimalGUI):
    def __init__(self, orchestrator=None):
        super().__init__(orchestrator)
    
    def show_correction_dialog(self, incorrect, alternatives):
        """Afficher le dialogue de correction"""
        correction = CorrectionDialog.show_correction_dialog(
            incorrect,
            alternatives,
            parent=self
        )
        return correction
    
    def show_action_result(self, action_result):
        """Afficher le résultat d'une action"""
        if action_result['result'] == 'success':
            notification = PostActionNotification.show_success(
                action_result['action_type'],
                action_result['target_element'],
                action_result['confidence'],
                parent=self
            )
        else:
            notification = PostActionNotification.show_failure(
                action_result['action_type'],
                action_result['target_element'],
                action_result.get('error_message', 'Erreur'),
                action_result['confidence'],
                parent=self
            )
            notification.correction_requested.connect(
                self.handle_correction_request
            )
    
    def show_autopilot_proposal(self, task_name, obs_count, concordance):
        """Afficher proposition autopilot"""
        notification = TransitionNotification.show_autopilot_proposal(
            task_name,
            obs_count,
            concordance,
            parent=self
        )
        notification.action_taken.connect(self.handle_autopilot_decision)
    
    def handle_correction_request(self, data):
        """Gérer une demande de correction"""
        # Implémenter la logique de correction
        pass
    
    def handle_autopilot_decision(self, action):
        """Gérer la décision autopilot"""
        if action == "accept":
            # Activer le mode autopilot
            pass
        elif action == "reject":
            # Rester en mode assisté
            pass

Tests

Chaque module contient un bloc if __name__ == "__main__" avec des tests de démonstration.

Pour tester individuellement:

# Test du dialogue de correction
python geniusia2/gui/dialogs/correction_dialog.py

# Test des notifications post-action
python geniusia2/gui/dialogs/post_action_notification.py

# Test des notifications de transition
python geniusia2/gui/dialogs/transition_notification.py

Architecture

gui/dialogs/
├── __init__.py                      # Exports des composants
├── correction_dialog.py             # Dialogue de correction
├── post_action_notification.py      # Notifications post-action
├── transition_notification.py       # Notifications de transition
└── README.md                        # Cette documentation

Dépendances

• PyQt5 (QWidget, QDialog, QLabel, QPushButton, etc.)
• numpy (pour les captures d'écran optionnelles)
• logging (pour la journalisation)

Notes d'Implémentation

Animations

Toutes les notifications utilisent des animations de glissement depuis la droite avec QPropertyAnimation.

Timeouts

• PostActionNotification: 5 secondes par défaut
• TransitionNotification: 6-10 secondes selon le type
• Les notifications nécessitant une action n'ont pas de timeout

Signaux PyQt5

Tous les composants utilisent des signaux pour la communication asynchrone:

• correction_made: Émis quand une correction est effectuée
• feedback_provided: Émis quand un retour est fourni
• action_taken: Émis quand une action utilisateur est prise

Style

Les couleurs et styles sont cohérents avec Material Design:

• Vert (#4CAF50): Succès, validation
• Rouge (#f44336): Échec, erreur
• Orange (#FF9800): Avertissement
• Bleu (#2196F3): Information