feat: application Courrier V1a socle et tri du jour (tt-2026-11-059)

This commit is contained in:
gemini-ops committed 2026-11-17 12:14:55 +01:00
1 parent 0199477821
commit b51a8bba69
19 files changed
+1731 -2

No files matched your search

+166
View File
@@ -0,0 +1,166 @@
import re
from typing import Optional, Dict, Any, List, Tuple
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 ""
# Nettoyage des préfixes et caractères spéciaux
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.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
rule_mot = (rule.get("mot_cle") or "").strip().lower()
if rule_mot:
# Vérifier si l'un des mots-clés de la règle est présent
mot_parts = rule_mot.split()
if any(p in mail_obj or p in mail_snip for p in mot_parts):
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)
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 "",
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 "")
classement = save_classement_manuel(
message_id=message_id,
categorie=new_category,
traite=traite,
expediteur=exp,
objet=obj,
date_mail=date_m,
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 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
# Réévaluation des emails non manuels en base
active_rules = list_regles(statut="active", db_path=db_path)
all_classements = list_classements(db_path=db_path)
for c in all_classements:
if c.get("source") == "manuel":
continue
mail_repr = {
"message_id": c["message_id"],
"expediteur": c.get("expediteur", ""),
"objet": c.get("objet", ""),
"apercu": "",
"etiquettes": []
}
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", ""),
db_path=db_path
)
return rule