Files
courrier/app/classifier.py
T

281 lines
12 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
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()