Fiche unique par mail via PrivAiTe (categorie proposee, confiance, resume, course, demande reelle), stockee sans corps de mail ; mode automatique distinct, desactive par defaut ; bloc Analyse IA dans la lecture (proposition, jamais appliquee sans clic) ; reglages IA dans Regles ; 20 tests (162 verts au total). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XGaEeTZLvHXfYPUNWkgYoi
348 lines
15 KiB
Python
348 lines
15 KiB
Python
"""Couche IA de Courrier, palier 2 (tt-2026-11-072) : analyse structuree d'un mail.
|
|
|
|
Un seul appel a PrivAiTe (alias courrier-main) renvoie une fiche : categorie proposee, resume,
|
|
course eventuelle (objets et documents a rapporter ou apporter), demande reelle ou simple information.
|
|
Regles fermes, heritees du palier 1 :
|
|
- tout passe par ia.appeler_privaite (seul point de sortie vers un modele), refus net si PrivAiTe est injoignable ;
|
|
- interrupteur ia_actif obligatoire ; mode automatique ia_auto distinct, desactive par defaut ;
|
|
- rien n'est applique : la categorie reste une suggestion, la course reste une proposition ;
|
|
- le corps du mail n'est jamais stocke ni journalise : seule la fiche produite est conservee ;
|
|
- aucun jeton, aucune adresse dans les journaux.
|
|
"""
|
|
import json
|
|
import logging
|
|
import re
|
|
import sqlite3
|
|
import threading
|
|
import time
|
|
from datetime import date as _date, timedelta
|
|
from email.utils import parsedate_to_datetime
|
|
from typing import Any, Dict, List, Optional
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from fastapi import APIRouter, HTTPException, Query
|
|
|
|
from app import db as _db
|
|
from app import ia
|
|
from app.config import get_tunis_now_iso
|
|
|
|
log = logging.getLogger("courrier.analyse")
|
|
|
|
MAX_RESUME = 600
|
|
MAX_ITEM = 160
|
|
MAX_ITEMS = 12
|
|
SENS_VALIDES = ("tunis_sfax", "sfax_tunis")
|
|
|
|
DEFINITIONS = {
|
|
"Tunis": "mails sur les courses, colis, documents ou personnes a deplacer entre Sfax et Tunis",
|
|
"Demande FB": "demandes d'achat ou de besoin venant de la direction financiere et budgetaire (FB)",
|
|
"CI": "mails de la cellule ou du circuit CI (controle interne, commandes internes)",
|
|
"Câbles": "mails sur les cables, fibres, equipements reseau et leur approvisionnement",
|
|
"Sans objet": "mails sans action pour Nabil : publicite, informations generales, copie sans suite",
|
|
}
|
|
|
|
|
|
def _pret(conn) -> None:
|
|
ia._pret(conn)
|
|
conn.execute(
|
|
"CREATE TABLE IF NOT EXISTS analyses_ia ("
|
|
"message_id TEXT PRIMARY KEY, categorie TEXT NOT NULL, confiance TEXT NOT NULL, resume TEXT NOT NULL, "
|
|
"course TEXT, demande TEXT, objet TEXT, expediteur TEXT, date_mail TEXT, le TEXT NOT NULL, modele TEXT NOT NULL)")
|
|
|
|
|
|
def _reglage(cle: str, db_path: Optional[str] = None) -> bool:
|
|
conn = _db.get_connection(db_path)
|
|
try:
|
|
_pret(conn)
|
|
r = conn.execute("SELECT valeur FROM reglages WHERE cle=?", (cle,)).fetchone()
|
|
return bool(r and r[0] == "1")
|
|
finally:
|
|
conn.close()
|
|
|
|
|
|
def _regler(cle: str, actif: bool, db_path: Optional[str] = None) -> None:
|
|
conn = _db.get_connection(db_path)
|
|
try:
|
|
_pret(conn)
|
|
with conn:
|
|
conn.execute("INSERT INTO reglages (cle, valeur, le) VALUES (?, ?, ?) "
|
|
"ON CONFLICT(cle) DO UPDATE SET valeur=excluded.valeur, le=excluded.le",
|
|
(cle, "1" if actif else "0", get_tunis_now_iso()))
|
|
finally:
|
|
conn.close()
|
|
|
|
|
|
def auto_actif(db_path: Optional[str] = None) -> bool:
|
|
return ia.ia_active(db_path) and _reglage("ia_auto", db_path)
|
|
|
|
|
|
def construire_messages(objet: str, expediteur: str, corps: str, categories: List[str]) -> list:
|
|
defs = "\n".join("- " + c + " : " + DEFINITIONS.get(c, "categorie de Nabil") for c in categories)
|
|
consigne = (
|
|
"Tu aides un responsable de la division Supply Chain de Tunisie Telecom (Sfax) a trier son courrier. "
|
|
"Analyse le mail et reponds UNIQUEMENT par un objet JSON sur une ligne, sans texte autour, avec ces cles :\n"
|
|
'{"categorie": <nom exact parmi la liste>, "confiance": "haute"|"moyenne"|"basse", '
|
|
'"resume": <2 phrases maximum en francais, faits utiles seulement>, '
|
|
'"course": null ou {"sens": "tunis_sfax"|"sfax_tunis", "objets": [<objets a rapporter ou apporter>], '
|
|
'"documents": [<documents a rapporter ou apporter>]}, '
|
|
'"demande": {"reelle": true|false, "action": <ce que Nabil doit faire, vide si information>, '
|
|
'"echeance": <JJ/MM/AAAA ou null>}}\n'
|
|
"Categories :\n" + defs + "\n"
|
|
"Choisis la categorie la plus probable, meme avec une confiance moyenne ; n'utilise "
|
|
+ ia.A_CLASSER + " que s'il n'existe vraiment aucun indice. "
|
|
"Une course existe seulement si le mail demande de rapporter, apporter ou deposer un objet ou un document "
|
|
"entre Sfax et Tunis. Une demande est reelle seulement si quelqu'un attend une action ou une reponse de Nabil. "
|
|
"N'invente rien : si l'information est absente, laisse vide ou null."
|
|
)
|
|
texte = ("Expediteur : " + (expediteur or "(inconnu)") + "\nObjet : " + (objet or "(vide)") + "\n\n"
|
|
+ (corps or "")[:ia.MAX_TEXTE])
|
|
return [{"role": "system", "content": consigne}, {"role": "user", "content": texte}]
|
|
|
|
|
|
def _court(v: Any, n: int) -> str:
|
|
return re.sub(r"\s+", " ", str(v or "")).strip()[:n]
|
|
|
|
|
|
def _liste(v: Any) -> List[str]:
|
|
if not isinstance(v, list):
|
|
return []
|
|
return [x for x in (_court(i, MAX_ITEM) for i in v[:MAX_ITEMS]) if x]
|
|
|
|
|
|
def lire_fiche(reponse: str, categories: List[str]) -> Dict[str, Any]:
|
|
"""Valide la reponse du modele. Toute anomalie degrade vers une fiche prudente, jamais vers une erreur."""
|
|
brut = reponse or ""
|
|
m = re.search(r"\{.*\}", brut, re.S)
|
|
try:
|
|
d = json.loads(m.group(0)) if m else {}
|
|
except ValueError:
|
|
d = {}
|
|
if not isinstance(d, dict):
|
|
d = {}
|
|
cat = ia.lire_categorie(str(d.get("categorie") or ""), categories)
|
|
conf = str(d.get("confiance") or "").lower()
|
|
if conf not in ("haute", "moyenne", "basse"):
|
|
conf = "basse"
|
|
if cat == ia.A_CLASSER:
|
|
conf = "basse"
|
|
course = None
|
|
c = d.get("course")
|
|
if isinstance(c, dict):
|
|
objets, docs = _liste(c.get("objets")), _liste(c.get("documents"))
|
|
if objets or docs:
|
|
sens = str(c.get("sens") or "")
|
|
course = {"sens": sens if sens in SENS_VALIDES else "tunis_sfax", "objets": objets, "documents": docs}
|
|
dm = d.get("demande") if isinstance(d.get("demande"), dict) else {}
|
|
action = _court(dm.get("action"), MAX_ITEM)
|
|
ech = _court(dm.get("echeance"), 10)
|
|
if not re.fullmatch(r"\d{2}/\d{2}/\d{4}", ech):
|
|
ech = ""
|
|
demande = {"reelle": bool(dm.get("reelle")) and bool(action), "action": action, "echeance": ech or None}
|
|
return {"categorie": cat, "confiance": conf, "resume": _court(d.get("resume"), MAX_RESUME),
|
|
"course": course, "demande": demande}
|
|
|
|
|
|
def _categories(db_path: Optional[str] = None) -> List[str]:
|
|
cats = [c["nom"] if "nom" in c else c.get("name") for c in _db.list_categories(db_path)]
|
|
return [c for c in cats if c and c != ia.A_CLASSER]
|
|
|
|
|
|
def analyser(objet: str, expediteur: str, corps: str, db_path: Optional[str] = None) -> Dict[str, Any]:
|
|
"""Appelle PrivAiTe. Leve IAIndisponible si le service ne repond pas (aucun repli)."""
|
|
cats = _categories(db_path)
|
|
rep = ia.appeler_privaite(construire_messages(objet, expediteur, corps, cats), max_tokens=450)
|
|
return lire_fiche(rep, cats)
|
|
|
|
|
|
def enregistrer(message_id: str, fiche: Dict[str, Any], objet: str = "", expediteur: str = "",
|
|
date_mail: str = "", db_path: Optional[str] = None) -> None:
|
|
conn = _db.get_connection(db_path)
|
|
try:
|
|
_pret(conn)
|
|
with conn:
|
|
conn.execute(
|
|
"INSERT INTO analyses_ia (message_id, categorie, confiance, resume, course, demande, objet, "
|
|
"expediteur, date_mail, le, modele) VALUES (?,?,?,?,?,?,?,?,?,?,?) "
|
|
"ON CONFLICT(message_id) DO UPDATE SET categorie=excluded.categorie, confiance=excluded.confiance, "
|
|
"resume=excluded.resume, course=excluded.course, demande=excluded.demande, le=excluded.le, "
|
|
"modele=excluded.modele",
|
|
(message_id, fiche["categorie"], fiche["confiance"], fiche["resume"],
|
|
json.dumps(fiche["course"], ensure_ascii=False) if fiche["course"] else None,
|
|
json.dumps(fiche["demande"], ensure_ascii=False),
|
|
_court(objet, 200), _court(expediteur, 120), _court(date_mail, 40),
|
|
get_tunis_now_iso(), ia.IA_MODELE))
|
|
finally:
|
|
conn.close()
|
|
|
|
|
|
def _ligne(r) -> Dict[str, Any]:
|
|
return {"message_id": r["message_id"], "categorie": r["categorie"], "confiance": r["confiance"],
|
|
"resume": r["resume"], "course": json.loads(r["course"]) if r["course"] else None,
|
|
"demande": json.loads(r["demande"]) if r["demande"] else None,
|
|
"objet": r["objet"], "expediteur": r["expediteur"], "date": r["date_mail"], "le": r["le"],
|
|
"appliquee": False}
|
|
|
|
|
|
def lire(message_id: str, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]:
|
|
conn = _db.get_connection(db_path)
|
|
try:
|
|
_pret(conn)
|
|
conn.row_factory = sqlite3.Row
|
|
r = conn.execute("SELECT * FROM analyses_ia WHERE message_id=?", (message_id,)).fetchone()
|
|
return _ligne(r) if r else None
|
|
finally:
|
|
conn.close()
|
|
|
|
|
|
def lister(jour: Optional[str] = None, depuis: Optional[str] = None, n: int = 100,
|
|
db_path: Optional[str] = None) -> List[Dict[str, Any]]:
|
|
conn = _db.get_connection(db_path)
|
|
try:
|
|
_pret(conn)
|
|
conn.row_factory = sqlite3.Row
|
|
sql, args = "SELECT * FROM analyses_ia", []
|
|
if jour:
|
|
sql += " WHERE date_mail LIKE ?"
|
|
args.append(jour + "%")
|
|
elif depuis:
|
|
sql += " WHERE date_mail >= ?"
|
|
args.append(depuis)
|
|
sql += " ORDER BY date_mail DESC, le DESC LIMIT ?"
|
|
args.append(max(1, min(n, 300)))
|
|
return [_ligne(r) for r in conn.execute(sql, args).fetchall()]
|
|
finally:
|
|
conn.close()
|
|
|
|
|
|
def _lire_mail(mirror_client, message_id: str):
|
|
res = mirror_client.get_mail(message_id)
|
|
d = res.get("donnees") if isinstance(res, dict) else None
|
|
if not isinstance(d, dict) or not d:
|
|
return None
|
|
eh = d.get("en_tetes") or {}
|
|
|
|
def h(nom):
|
|
return str(eh.get(nom) or eh.get(nom.lower()) or "")
|
|
date = h("Date")
|
|
try:
|
|
date = parsedate_to_datetime(date).astimezone(ZoneInfo("Africa/Tunis")).isoformat()
|
|
except Exception:
|
|
pass
|
|
return {"objet": h("Subject"), "de": h("From"), "date": date, "corps": str(d.get("corps_texte") or "")}
|
|
|
|
|
|
def analyser_mail(mirror_client, message_id: str, db_path: Optional[str] = None,
|
|
meta: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
|
|
m = _lire_mail(mirror_client, message_id)
|
|
if m is None:
|
|
raise LookupError("mail introuvable")
|
|
fiche = analyser(m["objet"], m["de"], m["corps"], db_path)
|
|
meta = meta or {}
|
|
enregistrer(message_id, fiche, meta.get("objet") or m["objet"], meta.get("expediteur") or m["de"],
|
|
meta.get("date") or m["date"], db_path)
|
|
return lire(message_id, db_path)
|
|
|
|
|
|
def traiter_lot(mirror_client, jour: str, maximum: int = 5, db_path: Optional[str] = None) -> Dict[str, int]:
|
|
"""Analyse les mails du jour qui n'ont pas encore de fiche. Comptes seulement, aucun contenu."""
|
|
res = {"analyses": 0, "deja": 0, "erreurs": 0, "restant": 0}
|
|
mails = mirror_client.get_mails_for_day(jour, max_items=60)
|
|
faits = {a["message_id"] for a in lister(jour=jour, n=300, db_path=db_path)}
|
|
a_faire = [m for m in mails if m.get("message_id") and m["message_id"] not in faits]
|
|
res["deja"] = len(mails) - len(a_faire)
|
|
for m in a_faire[:maximum]:
|
|
try:
|
|
analyser_mail(mirror_client, m["message_id"], db_path,
|
|
{"objet": m.get("objet"), "expediteur": m.get("expediteur"), "date": m.get("date")})
|
|
res["analyses"] += 1
|
|
except ia.IAIndisponible:
|
|
res["erreurs"] += 1
|
|
break
|
|
except Exception:
|
|
res["erreurs"] += 1
|
|
res["restant"] = max(0, len(a_faire) - res["analyses"] - res["erreurs"])
|
|
return res
|
|
|
|
|
|
_verrou = threading.Lock()
|
|
|
|
|
|
def demarrer_automatique(mirror_client, intervalle: int = 180) -> None:
|
|
"""Boucle de fond : tant que ia_actif ET ia_auto sont vrais, analyse les mails du jour par petits lots."""
|
|
def boucle() -> None:
|
|
while True:
|
|
time.sleep(intervalle)
|
|
try:
|
|
if auto_actif() and _verrou.acquire(blocking=False):
|
|
try:
|
|
r = traiter_lot(mirror_client, get_tunis_now_iso()[:10])
|
|
if r["analyses"] or r["erreurs"]:
|
|
log.info("analyse auto : %s", r)
|
|
finally:
|
|
_verrou.release()
|
|
except Exception as e:
|
|
log.warning("analyse auto : %s", type(e).__name__)
|
|
threading.Thread(target=boucle, daemon=True, name="courrier-ia-auto").start()
|
|
|
|
|
|
def creer_routeur(mirror_client) -> APIRouter:
|
|
router = APIRouter(prefix="/ia")
|
|
|
|
@router.get("/auto")
|
|
def etat_auto():
|
|
return {"auto": _reglage("ia_auto"), "actif": ia.ia_active()}
|
|
|
|
@router.put("/auto")
|
|
def regler_auto(e: ia.IAEtat):
|
|
_regler("ia_auto", e.actif)
|
|
return {"auto": _reglage("ia_auto"), "actif": ia.ia_active()}
|
|
|
|
@router.get("/analyse")
|
|
def lire_analyse(id: str = Query(..., min_length=1, max_length=400)):
|
|
"""Fiche deja produite (aucun appel de modele)."""
|
|
r = lire(id)
|
|
if r is None:
|
|
raise HTTPException(status_code=404, detail="Aucune analyse pour ce mail.")
|
|
return r
|
|
|
|
@router.post("/analyse")
|
|
def produire_analyse(id: str = Query(..., min_length=1, max_length=400)):
|
|
if not ia.ia_active():
|
|
raise HTTPException(status_code=409, detail="L'IA est désactivée.")
|
|
try:
|
|
return analyser_mail(mirror_client, id)
|
|
except LookupError:
|
|
raise HTTPException(status_code=404, detail="Mail introuvable.")
|
|
except ia.IAIndisponible as e:
|
|
raise HTTPException(status_code=503, detail="IA indisponible, aucune analyse : " + str(e) + ".")
|
|
except HTTPException:
|
|
raise
|
|
except Exception:
|
|
raise HTTPException(status_code=502, detail="Lecture du mail impossible : miroir indisponible.")
|
|
|
|
@router.post("/lot")
|
|
def produire_lot(date: Optional[str] = None, maximum: int = Query(5, ge=1, le=20)):
|
|
if not ia.ia_active():
|
|
raise HTTPException(status_code=409, detail="L'IA est désactivée.")
|
|
jour = date or get_tunis_now_iso()[:10]
|
|
if not _verrou.acquire(blocking=False):
|
|
raise HTTPException(status_code=429, detail="Un lot est déjà en cours.")
|
|
try:
|
|
return traiter_lot(mirror_client, jour, maximum)
|
|
except ia.IAIndisponible as e:
|
|
raise HTTPException(status_code=503, detail="IA indisponible : " + str(e) + ".")
|
|
except Exception:
|
|
raise HTTPException(status_code=502, detail="Lecture du miroir impossible.")
|
|
finally:
|
|
_verrou.release()
|
|
|
|
@router.get("/analyses")
|
|
def lister_analyses(date: Optional[str] = None, jours: int = Query(7, ge=1, le=60),
|
|
n: int = Query(100, ge=1, le=300)):
|
|
if date:
|
|
return {"analyses": lister(jour=date, n=n)}
|
|
debut = (_date.fromisoformat(get_tunis_now_iso()[:10]) - timedelta(days=jours)).isoformat()
|
|
return {"analyses": lister(depuis=debut, n=n)}
|
|
|
|
return router
|