"""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": , "confiance": "haute"|"moyenne"|"basse", ' '"resume": <2 phrases maximum en francais, faits utiles seulement>, ' '"course": null ou {"sens": "tunis_sfax"|"sfax_tunis", "objets": [], ' '"documents": []}, ' '"demande": {"reelle": true|false, "action": , ' '"echeance": }}\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 def _routeur_regles_auto(): from fastapi import APIRouter from pydantic import BaseModel from app import classifier as _c r = APIRouter() class Etat(BaseModel): actif: bool @r.get("/regles/auto") def lire_regles_auto(): return {"actif": _c.regles_auto_actives()} @r.put("/regles/auto") def regler_regles_auto(e: Etat): _c.regler_regles_auto(e.actif) return {"actif": _c.regles_auto_actives()} return r