Files
courrier/app/classifier.py
T

217 lines
8.0 KiB
Python

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