import re from typing import Optional, Dict, Any, List, Tuple from app.db import ( list_regles, get_regle, add_regle, confirm_regle, get_classement, list_classements, save_classement_regle, save_classement_manuel ) STOPWORDS = { "re", "fwd", "tr", "de", "du", "des", "le", "la", "les", "un", "une", "et", "en", "pour", "sur", "avec", "dans", "par", "au", "aux", "ce", "cet", "cette", "ces", "a", "à", "the", "of", "to", "in", "for", "and", "is", "on", "at", "by" } def extract_keywords(text: Optional[str]) -> str: """Extrait les mots significatifs d'un objet de mail.""" if not text: return "" # Nettoyage des préfixes et caractères spéciaux clean = re.sub(r"^(?:re|fwd|tr)\s*:\s*", "", text, flags=re.IGNORECASE) words = re.findall(r"\b[\w\u00C0-\u017F-]{3,}\b", clean, flags=re.UNICODE) meaningful = [w for w in words if w.lower() not in STOPWORDS] return " ".join(meaningful[:3]) def match_mail_to_rules(mail: Dict[str, Any], rules: List[Dict[str, Any]]) -> str: """ Associe un mail à une catégorie selon les règles actives. Retourne la catégorie correspondante, ou 'À classer' par défaut. """ mail_exp = (mail.get("expediteur") or mail.get("from") or "").lower() mail_obj = (mail.get("objet") or mail.get("subject") or "").lower() mail_snip = (mail.get("apercu") or mail.get("snippet") or "").lower() mail_tags = [t.lower() for t in (mail.get("etiquettes") or mail.get("tags") or [])] for rule in rules: if rule.get("statut") != "active": continue # 1. Correspondance sur l'étiquette miroir rule_tag = (rule.get("etiquette_miroir") or "").strip().lower() if rule_tag and rule_tag in mail_tags: return rule["categorie"] # 2. Correspondance sur l'expéditeur rule_exp = (rule.get("expediteur") or "").strip().lower() if rule_exp and rule_exp in mail_exp: return rule["categorie"] # 3. Correspondance sur les mots-clés rule_mot = (rule.get("mot_cle") or "").strip().lower() if rule_mot: # Vérifier si l'un des mots-clés de la règle est présent mot_parts = rule_mot.split() if any(p in mail_obj or p in mail_snip for p in mot_parts): return rule["categorie"] return "À classer" def classify_mail(mail: Dict[str, Any], db_path: Optional[str] = None) -> Dict[str, Any]: """ Classe un email en appliquant les règles si aucun classement manuel n'existe. RÈGLE ABSOLUE : Un classement manuel n'est jamais écrasé par une règle. """ mid = mail.get("message_id") if not mid: raise ValueError("message_id obligatoire pour classer un mail.") existing = get_classement(mid, db_path) if existing and existing.get("source") == "manuel": # Conserver le classement manuel existant return existing rules = list_regles(statut="active", db_path=db_path) categorie = match_mail_to_rules(mail, rules) return save_classement_regle( message_id=mid, categorie=categorie, expediteur=mail.get("expediteur") or mail.get("from") or "", objet=mail.get("objet") or mail.get("subject") or "", date_mail=mail.get("date") or "", db_path=db_path ) def manual_classify_and_propose( message_id: str, new_category: str, mail_info: Optional[Dict[str, Any]] = None, traite: Optional[bool] = None, db_path: Optional[str] = None ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]: """ Pose un classement manuel. Une correction manuelle propose une règle (même expéditeur et mêmes mots), qui ne s'applique qu'une fois confirmée. """ existing = get_classement(message_id, db_path) exp = (mail_info.get("expediteur") if mail_info else None) or (existing.get("expediteur") if existing else "") obj = (mail_info.get("objet") if mail_info else None) or (existing.get("objet") if existing else "") date_m = (mail_info.get("date") if mail_info else None) or (existing.get("date_mail") if existing else "") classement = save_classement_manuel( message_id=message_id, categorie=new_category, traite=traite, expediteur=exp, objet=obj, date_mail=date_m, db_path=db_path ) # Proposition d'une règle basée sur l'expéditeur et les mots-clés mots = extract_keywords(obj) proposed_rule = None if exp or mots: proposed_rule = add_regle( categorie=new_category, expediteur=exp or None, mot_cle=mots or None, statut="proposee", db_path=db_path ) return classement, proposed_rule def confirm_and_apply_rule(regle_id: int, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: """ Confirme une règle proposée (statut='active') et applique les règles actives à tous les classements non-manuels. RÈGLE ABSOLUE : Les classements manuels ne sont jamais touchés. """ rule = confirm_regle(regle_id, db_path) if not rule: return None # Réévaluation des emails non manuels en base active_rules = list_regles(statut="active", db_path=db_path) all_classements = list_classements(db_path=db_path) for c in all_classements: if c.get("source") == "manuel": continue mail_repr = { "message_id": c["message_id"], "expediteur": c.get("expediteur", ""), "objet": c.get("objet", ""), "apercu": "", "etiquettes": [] } new_cat = match_mail_to_rules(mail_repr, active_rules) if new_cat != c.get("categorie"): save_classement_regle( message_id=c["message_id"], categorie=new_cat, expediteur=c.get("expediteur", ""), objet=c.get("objet", ""), date_mail=c.get("date_mail", ""), db_path=db_path ) return rule