Files
courrier/app/analyse.py
T

626 lines
29 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)")
cols = {r[1] for r in conn.execute("PRAGMA table_info(analyses_ia)")}
if "fil" not in cols:
conn.execute("ALTER TABLE analyses_ia ADD COLUMN fil TEXT")
conn.execute("CREATE INDEX IF NOT EXISTS idx_analyses_fil ON analyses_ia (fil)")
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], contexte: str = "", exemples: 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."
)
if exemples:
consigne += ("\nExemples de choix reels de Nabil sur ses propres mails (objet, expediteur, categorie qu'il a retenue ou refusee). "
"Ce ne sont pas des regles a appliquer mot pour mot : un meme expediteur ou un meme objet peut relever d'une autre categorie un autre jour, "
"decide d'apres le contenu. Inspire-toi de sa facon de ranger :\n" + exemples + "\n")
if contexte:
consigne += ("\nLe mail fait partie d'une conversation : un contexte (resumes des mails precedents du meme fil, "
"et categorie choisie par Nabil quand elle existe) est fourni. Utilise-le : un fil deja range par Nabil "
"garde sa categorie, et un mail de suite sans nouvelle demande n'est pas une nouvelle course.")
texte = ("Expediteur : " + (expediteur or "(inconnu)") + "\nObjet : " + (objet or "(vide)") + "\n\n"
+ (corps or "")[:ia.MAX_TEXTE])
if contexte:
texte = "Contexte du fil :\n" + contexte + "\n\nMail a analyser :\n" + 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, contexte: str = "") -> Dict[str, Any]:
exemples = exemples_nabil(db_path)
"""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, contexte, exemples), max_tokens=1200)
return lire_fiche(rep, cats)
def cle_fil(thread_index: str) -> Optional[str]:
"""Cle de conversation Exchange : les 22 premiers octets de Thread-Index sont communs a tout le fil,
meme quand l'objet change. Vide si l'en-tete est absent ou illisible."""
import base64
try:
brut = base64.b64decode((thread_index or "").strip() + "=" * (-len(thread_index.strip()) % 4))
except Exception:
return None
return brut[:22].hex() if len(brut) >= 22 else None
def enregistrer(message_id: str, fiche: Dict[str, Any], objet: str = "", expediteur: str = "",
date_mail: str = "", db_path: Optional[str] = None, fil: 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, fil) 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, fil=COALESCE(excluded.fil, fil)",
(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, fil))
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 membres_fil(fil: Optional[str], message_id: str = "", db_path: Optional[str] = None, n: int = 8) -> List[Dict[str, Any]]:
"""Autres mails deja analyses du meme fil, du plus ancien au plus recent, avec la categorie choisie par Nabil."""
if not fil:
return []
conn = _db.get_connection(db_path)
try:
_pret(conn)
conn.row_factory = sqlite3.Row
lignes = conn.execute("SELECT * FROM analyses_ia WHERE fil=? AND message_id<>? ORDER BY date_mail DESC LIMIT ?",
(fil, message_id, max(1, min(n, 20)))).fetchall()
sortie = []
for r in reversed(lignes):
f = _ligne(r)
c = conn.execute("SELECT categorie, source FROM classements WHERE message_id=?", (r["message_id"],)).fetchone()
f["choix_nabil"] = c[0] if c and c[1] == "manuel" else None
sortie.append(f)
return sortie
finally:
conn.close()
def contexte_fil(fil: Optional[str], message_id: str, db_path: Optional[str] = None) -> str:
lignes = []
for f in membres_fil(fil, message_id, db_path, 5):
lignes.append("- " + (f["date"] or "")[:10] + " | " + _court(f["objet"], 100) + " | "
+ ("categorie choisie par Nabil : " + f["choix_nabil"] if f["choix_nabil"] else "categorie proposee : " + f["categorie"])
+ " | " + _court(f["resume"], 220))
return "\n".join(lignes)
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 ""),
"fil": cle_fil(h("Thread-Index"))}
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, contexte_fil(m.get("fil"), message_id, 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, m.get("fil"))
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()
# ---------- File « A valider » : propositions de l'IA que Nabil accepte ou refuse ----------
def _pret_decisions(conn) -> None:
conn.execute("CREATE TABLE IF NOT EXISTS decisions_ia (message_id TEXT NOT NULL, type TEXT NOT NULL, "
"decision TEXT NOT NULL, le TEXT NOT NULL, PRIMARY KEY (message_id, type))")
def a_valider(jours: int = 14, db_path: Optional[str] = None) -> List[Dict[str, Any]]:
"""Propositions en attente : une categorie differente du classement actuel (jamais sur un classement
manuel), une course possible pas encore creee. Une proposition deja acceptee ou refusee ne revient pas."""
depuis = (_date.fromisoformat(get_tunis_now_iso()[:10]) - timedelta(days=max(1, min(jours, 60)))).isoformat()
conn = _db.get_connection(db_path)
try:
_pret(conn); _pret_decisions(conn)
conn.row_factory = sqlite3.Row
decides = {(r[0], r[1]) for r in conn.execute("SELECT message_id, type FROM decisions_ia")}
cl = {r[0]: (r[1], r[2]) for r in conn.execute("SELECT message_id, categorie, source FROM classements")}
try:
courses = {r[0] for r in conn.execute("SELECT message_id FROM courses WHERE message_id IS NOT NULL")}
except sqlite3.OperationalError:
courses = set()
lignes = conn.execute("SELECT * FROM analyses_ia WHERE date_mail >= ? ORDER BY date_mail DESC LIMIT 300",
(depuis,)).fetchall()
sortie: List[Dict[str, Any]] = []
for r in lignes:
f = _ligne(r); mid = f["message_id"]
base = {"message_id": mid, "objet": f["objet"], "expediteur": f["expediteur"], "date": f["date"],
"resume": f["resume"], "confiance": f["confiance"]}
actuelle, source = cl.get(mid, ("À classer", "regle"))
if (mid, "categorie") not in decides and source != "manuel" and f["categorie"] not in ("À classer", actuelle):
sortie.append(dict(base, type="categorie", actuelle=actuelle, propose=f["categorie"]))
c = f["course"]
if c and (mid, "course") not in decides and mid not in courses:
liste = ", ".join((c.get("objets") or []) + (c.get("documents") or []))
if liste:
sortie.append(dict(base, type="course", propose=liste, sens=c.get("sens") or "tunis_sfax"))
return sortie
finally:
conn.close()
def decider(message_id: str, type_: str, decision: str, db_path: Optional[str] = None) -> Dict[str, Any]:
"""Accepter applique la proposition (classement manuel ou course) ; refuser la ferme. Toujours un clic."""
if type_ not in ("categorie", "course") or decision not in ("accepter", "refuser"):
raise ValueError("decision invalide")
f = lire(message_id, db_path)
if not f:
raise LookupError("analyse introuvable")
resultat: Dict[str, Any] = {"ok": True}
if decision == "accepter":
if type_ == "categorie":
from app.classifier import manual_classify_and_propose
manual_classify_and_propose(message_id, f["categorie"], {"expediteur": f["expediteur"], "objet": f["objet"],
"date": f["date"]}, db_path=db_path)
else:
c = f["course"] or {}
liste = ", ".join((c.get("objets") or []) + (c.get("documents") or []))
if not liste:
raise LookupError("pas de course proposee")
resultat["course"] = _db.add_course(liste[:300], c.get("sens") or "tunis_sfax", message_id,
(f["objet"] or "")[:500], (f["expediteur"] or "")[:300],
(f["date"] or "")[:40], db_path=db_path)
conn = _db.get_connection(db_path)
try:
_pret_decisions(conn); _decisions_pret(conn)
valeur = f["categorie"] if type_ == "categorie" else ", ".join(((f["course"] or {}).get("objets") or []) + ((f["course"] or {}).get("documents") or []))
with conn:
conn.execute("INSERT INTO decisions_ia (message_id, type, decision, le, valeur, objet, expediteur) VALUES (?, ?, ?, ?, ?, ?, ?) "
"ON CONFLICT(message_id, type) DO UPDATE SET decision=excluded.decision, le=excluded.le, "
"valeur=excluded.valeur, objet=excluded.objet, expediteur=excluded.expediteur",
(message_id, type_, decision, get_tunis_now_iso(), valeur[:200], _court(f["objet"], 200), _court(f["expediteur"], 120)))
finally:
conn.close()
return resultat
# ---------- Apprentissage par exemples : les choix de Nabil guident l'IA, sans aucune regle ----------
def _decisions_pret(conn) -> None:
conn.execute("CREATE TABLE IF NOT EXISTS decisions_ia (message_id TEXT NOT NULL, type TEXT NOT NULL, "
"decision TEXT NOT NULL, le TEXT NOT NULL, PRIMARY KEY (message_id, type))")
cols = {r[1] for r in conn.execute("PRAGMA table_info(decisions_ia)")}
for c in ("valeur", "objet", "expediteur"):
if c not in cols:
conn.execute("ALTER TABLE decisions_ia ADD COLUMN %s TEXT" % c)
def exemples_nabil(db_path: Optional[str] = None, par_categorie: int = 3, maximum: int = 14, refus: int = 4) -> str:
"""Quelques classements manuels recents (au plus 3 par categorie) et quelques refus. Objet et expediteur seulement,
jamais le corps ; l'ensemble passe par PrivAiTe comme le reste."""
conn = _db.get_connection(db_path)
try:
_decisions_pret(conn)
lignes = conn.execute("SELECT categorie, objet, expediteur FROM classements WHERE source='manuel' "
"AND categorie<>'À classer' AND objet<>'' ORDER BY horodatage DESC LIMIT 200").fetchall()
compte: Dict[str, int] = {}
sortie: List[str] = []
for cat, obj, exp in lignes:
if compte.get(cat, 0) >= par_categorie or len(sortie) >= maximum:
continue
compte[cat] = compte.get(cat, 0) + 1
sortie.append("- %s | %s => %s" % (_court(obj, 90), _court(exp, 50), cat))
for val, obj, exp in conn.execute("SELECT valeur, objet, expediteur FROM decisions_ia WHERE type='categorie' "
"AND decision='refuser' AND valeur IS NOT NULL ORDER BY le DESC LIMIT ?", (refus,)):
sortie.append("- %s | %s => PAS %s (propose puis refuse)" % (_court(obj, 90), _court(exp, 50), val))
return "\n".join(sortie)
except sqlite3.OperationalError:
return ""
finally:
conn.close()
def stats_acceptation(db_path: Optional[str] = None) -> Dict[str, Any]:
conn = _db.get_connection(db_path)
try:
_decisions_pret(conn)
cats: Dict[str, Dict[str, int]] = {}
tot = {"acceptees": 0, "refusees": 0}
for typ, dec, val, n in conn.execute("SELECT type, decision, COALESCE(valeur,''), COUNT(*) FROM decisions_ia GROUP BY 1,2,3"):
cle = val if typ == "categorie" and val else ("Courses" if typ == "course" else "Autres")
d = cats.setdefault(cle, {"acceptees": 0, "refusees": 0})
k = "acceptees" if dec == "accepter" else "refusees"
d[k] += n; tot[k] += n
return {"total": tot, "categories": cats}
finally:
conn.close()
def briefing(jour: Optional[str] = None, db_path: Optional[str] = None) -> Dict[str, Any]:
"""Briefing du matin : uniquement des fiches deja produites et des tables locales, aucun appel de modele.
Demandes encore ouvertes = demandes reelles des 7 derniers jours dont le mail n'est pas marque traite."""
jour = jour or get_tunis_now_iso()[:10]
depuis = (_date.fromisoformat(jour) - timedelta(days=7)).isoformat()
conn = _db.get_connection(db_path)
try:
_pret(conn)
conn.row_factory = sqlite3.Row
traites = {r[0] for r in conn.execute("SELECT message_id FROM classements WHERE traite = 1")}
ouvertes, echeances = [], []
for r in conn.execute("SELECT * FROM analyses_ia WHERE date_mail >= ? ORDER BY date_mail DESC LIMIT 300", (depuis,)):
f = _ligne(r)
d = f["demande"] or {}
if d.get("reelle") and f["message_id"] not in traites:
it = {"message_id": f["message_id"], "objet": f["objet"], "expediteur": f["expediteur"],
"date": f["date"], "action": d.get("action"), "echeance": d.get("echeance")}
ouvertes.append(it)
try:
courses = [dict(x) for x in conn.execute("SELECT id, demande, sens, statut FROM courses WHERE statut = 'a_faire' ORDER BY id DESC LIMIT 30")]
except sqlite3.OperationalError:
courses = []
try:
suivi = [dict(x) for x in conn.execute("SELECT objet, expediteur, marque_le FROM a_suivre WHERE statut = 'actif' ORDER BY marque_le DESC LIMIT 30")]
except sqlite3.OperationalError:
suivi = []
repart = [dict(x) for x in conn.execute(
"SELECT categorie, COUNT(*) AS mails, SUM(traite) AS traites FROM classements WHERE date_mail LIKE ? GROUP BY categorie ORDER BY mails DESC", (jour + "%",))]
finally:
conn.close()
def cle(i):
e = i["echeance"] or ""
return (e[6:] + e[3:5] + e[:2]) if e else "99999999"
ouvertes.sort(key=cle)
return {"jour": jour, "demandes_ouvertes": ouvertes, "propositions_a_valider": len(a_valider(14, db_path)),
"courses_a_faire": courses, "a_suivre_actifs": suivi, "repartition_du_jour": repart}
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)}
@router.get("/fil")
def lire_fil(id: str = Query(..., min_length=1, max_length=400)):
f = lire(id)
conn = _db.get_connection()
try:
_pret(conn)
r = conn.execute("SELECT fil FROM analyses_ia WHERE message_id=?", (id,)).fetchone()
finally:
conn.close()
fil = r[0] if r else None
return {"fil": bool(fil), "mails": membres_fil(fil, id, None, 12)}
@router.get("/briefing")
def briefing_matin(date: Optional[str] = None):
return briefing(date)
@router.get("/stats")
def stats_ia():
return stats_acceptation()
@router.get("/a-valider")
def liste_a_valider(jours: int = Query(14, ge=1, le=60)):
return {"items": a_valider(jours)}
@router.post("/decision")
def decision_ia(corps: Dict[str, Any]):
try:
return decider(str(corps.get("message_id") or ""), str(corps.get("type") or ""), str(corps.get("decision") or ""))
except ValueError:
raise HTTPException(status_code=422, detail="Decision invalide.")
except LookupError:
raise HTTPException(status_code=404, detail="Proposition introuvable.")
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