import re import json from typing import Optional, Dict, Any, List, Tuple from app.config import get_tunis_now_iso 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 "" 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.strip().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 (avec frontières de mots pour éviter les faux-positifs) rule_mot = (rule.get("mot_cle") or "").strip().lower() if rule_mot: pattern = rf"\b{re.escape(rule_mot)}\b" if re.search(pattern, mail_obj, re.IGNORECASE) or re.search(pattern, mail_snip, re.IGNORECASE): 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) tags = mail.get("etiquettes") or mail.get("tags") or [] tags_json = json.dumps(tags) if isinstance(tags, list) else str(tags) 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 "", etiquettes=tags_json, 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 "") tags = (mail_info.get("etiquettes") if mail_info else None) or (existing.get("etiquettes") if existing else "[]") tags_json = json.dumps(tags) if isinstance(tags, list) else str(tags) classement = save_classement_manuel( message_id=message_id, categorie=new_category, traite=traite, expediteur=exp, objet=obj, date_mail=date_m, etiquettes=tags_json, 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 reclassify_all_non_manual(db_path: Optional[str] = None, date_prefix: Optional[str] = None) -> int: """ Réévalue et reclasse tous les emails non-manuels enregistrés en base. RÈGLE ABSOLUE : Les classements manuels ne sont jamais touchés. """ active_rules = list_regles(statut="active", db_path=db_path) all_classements = list_classements(date_prefix=date_prefix, db_path=db_path) reclassified_count = 0 for c in all_classements: if c.get("source") == "manuel": continue raw_tags = c.get("etiquettes") or "[]" try: tags = json.loads(raw_tags) if isinstance(raw_tags, str) else raw_tags except Exception: tags = [] mail_repr = { "message_id": c["message_id"], "expediteur": c.get("expediteur", ""), "objet": c.get("objet", ""), "apercu": "", "etiquettes": tags if isinstance(tags, list) else [] } 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", ""), etiquettes=raw_tags if isinstance(raw_tags, str) else json.dumps(raw_tags), db_path=db_path ) reclassified_count += 1 return reclassified_count def reclassify_today_mails(mirror_client: Optional[Any] = None, db_path: Optional[str] = None, target_date: Optional[str] = None) -> int: """ Reclasse les mails du jour : interroge le miroir pour synchroniser les étiquettes et applique les règles actives, sans jamais écraser un classement manuel. """ t_date = target_date or get_tunis_now_iso()[:10] total_processed = 0 if mirror_client: try: mails = mirror_client.get_mails_for_day(t_date, max_items=50) for m in mails: classify_mail(m, db_path=db_path) total_processed += 1 except Exception: pass # Reclassement de sécurité sur les données déjà en base reclassify_all_non_manual(db_path=db_path, date_prefix=t_date) return total_processed 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 reclassify_all_non_manual(db_path=db_path) return rule