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 [])] # OBJET-VIDE-060 : règle de départ « objet vide » -> Sans objet (le miroir fournit « sujet » vide) if not mail_obj.strip(): return "Sans objet" 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 def classify_batch(mails: List[Dict[str, Any]], db_path: Optional[str] = None) -> List[Dict[str, Any]]: """Classe un lot de mails en une seule connexion : règles lues une fois, classements existants lus en une requête, écriture seulement quand un classement change (nouveau mail ou règle modifiée), le tout en une transaction. Un classement manuel n'est jamais écrasé. Même résultat que classify_mail, mail par mail.""" from app.db import get_connection from app.config import get_tunis_now_iso mails = [m for m in mails if m.get("message_id")] if not mails: return [] rules = list_regles(statut="active", db_path=db_path) conn = get_connection(db_path) try: ids = [m["message_id"] for m in mails] existants: Dict[str, Dict[str, Any]] = {} for i in range(0, len(ids), 400): lot = ids[i:i + 400] req = ("SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes " "FROM classements WHERE message_id IN (%s)" % ",".join("?" * len(lot))) for r in conn.execute(req, lot): d = dict(r) d["traite"] = bool(d["traite"]) existants[d["message_id"]] = d maintenant = get_tunis_now_iso() sortie: List[Dict[str, Any]] = [] ecritures = [] for m in mails: mid = m["message_id"] ex = existants.get(mid) if ex and ex.get("source") == "manuel": sortie.append(ex) continue categorie = match_mail_to_rules(m, rules) tags = m.get("etiquettes") or m.get("tags") or [] tags_json = json.dumps(tags) if isinstance(tags, list) else str(tags) exp = (m.get("expediteur") or m.get("from") or "") or (ex["expediteur"] if ex else "") obj = (m.get("objet") or m.get("subject") or "") or (ex["objet"] if ex else "") date_mail = (m.get("date") or "") or (ex["date_mail"] if ex else "") etiq = tags_json if tags_json != "[]" else ((ex.get("etiquettes") if ex else None) or "[]") if ex and (ex["categorie"], ex["expediteur"], ex["objet"], ex["date_mail"], ex.get("etiquettes") or "[]") == (categorie, exp, obj, date_mail, etiq): sortie.append(ex) # inchangé : aucune écriture continue traite = ex["traite"] if ex else False ecritures.append((mid, categorie, maintenant, 1 if traite else 0, exp, obj, date_mail, etiq)) sortie.append({"message_id": mid, "categorie": categorie, "source": "regle", "horodatage": maintenant, "traite": traite, "expediteur": exp, "objet": obj, "date_mail": date_mail, "etiquettes": etiq}) if ecritures: with conn: conn.executemany( """ INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes) VALUES (?, ?, 'regle', ?, ?, ?, ?, ?, ?) ON CONFLICT(message_id) DO UPDATE SET categorie = excluded.categorie, source = 'regle', horodatage = excluded.horodatage, expediteur = excluded.expediteur, objet = excluded.objet, date_mail = excluded.date_mail, etiquettes = CASE WHEN excluded.etiquettes != '[]' THEN excluded.etiquettes ELSE classements.etiquettes END WHERE classements.source != 'manuel' """, ecritures) return sortie finally: conn.close()