Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XGaEeWkqZYNP6Wn3mGQsrL
281 lines
12 KiB
Python
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()
|