diff --git a/app/analyse.py b/app/analyse.py index d6e8f90..22d7e4b 100644 --- a/app/analyse.py +++ b/app/analyse.py @@ -345,3 +345,23 @@ def creer_routeur(mirror_client) -> APIRouter: 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 diff --git a/app/classifier.py b/app/classifier.py index 4ca61bb..1dfb1c6 100644 --- a/app/classifier.py +++ b/app/classifier.py @@ -19,6 +19,40 @@ STOPWORDS = { "ces", "a", "à", "the", "of", "to", "in", "for", "and", "is", "on", "at", "by" } +def regles_auto_actives(db_path: Optional[str] = None) -> bool: + """Reglage global : les regles automatiques (mots-cles, expediteur, etiquette) ne decident plus + du classement ni des courses tant qu'il est eteint (defaut). Decision de Nabil du 20/11/2026 : + un meme expediteur ou un meme objet ne dit pas la meme chose d'un jour a l'autre, c'est le contenu + (lu par l'IA, propose puis valide) qui decide.""" + from app.db import get_connection + conn = get_connection(db_path) + try: + conn.execute("CREATE TABLE IF NOT EXISTS reglages (cle TEXT PRIMARY KEY, valeur TEXT NOT NULL, le TEXT NOT NULL)") + r = conn.execute("SELECT valeur FROM reglages WHERE cle='regles_auto'").fetchone() + return bool(r and r[0] == "1") + finally: + conn.close() + + +def regler_regles_auto(actif: bool, db_path: Optional[str] = None) -> None: + from app.db import get_connection + conn = get_connection(db_path) + try: + conn.execute("CREATE TABLE IF NOT EXISTS reglages (cle TEXT PRIMARY KEY, valeur TEXT NOT NULL, le TEXT NOT NULL)") + with conn: + conn.execute("INSERT INTO reglages (cle, valeur, le) VALUES ('regles_auto', ?, ?) " + "ON CONFLICT(cle) DO UPDATE SET valeur=excluded.valeur, le=excluded.le", + ("1" if actif else "0", get_tunis_now_iso())) + finally: + conn.close() + + +def _regles_actives(db_path: Optional[str] = None) -> List[Dict[str, Any]]: + if not regles_auto_actives(db_path): + return [] + return list_regles(statut="active", db_path=db_path) + + def extract_keywords(text: Optional[str]) -> str: """Extrait les mots significatifs d'un objet de mail.""" if not text: @@ -79,7 +113,7 @@ def classify_mail(mail: Dict[str, Any], db_path: Optional[str] = None) -> Dict[s # Conserver le classement manuel existant return existing - rules = list_regles(statut="active", db_path=db_path) + rules = _regles_actives(db_path) categorie = match_mail_to_rules(mail, rules) tags = mail.get("etiquettes") or mail.get("tags") or [] @@ -129,7 +163,7 @@ def manual_classify_and_propose( # 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: + if (exp or mots) and regles_auto_actives(db_path): proposed_rule = add_regle( categorie=new_category, expediteur=exp or None, @@ -145,7 +179,7 @@ def reclassify_all_non_manual(db_path: Optional[str] = None, date_prefix: Option 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) + active_rules = _regles_actives(db_path) all_classements = list_classements(date_prefix=date_prefix, db_path=db_path) reclassified_count = 0 @@ -226,7 +260,7 @@ def classify_batch(mails: List[Dict[str, Any]], db_path: Optional[str] = None) - mails = [m for m in mails if m.get("message_id")] if not mails: return [] - rules = list_regles(statut="active", db_path=db_path) + rules = _regles_actives(db_path) conn = get_connection(db_path) try: ids = [m["message_id"] for m in mails] diff --git a/app/main.py b/app/main.py index 2bec3c7..45aeb60 100644 --- a/app/main.py +++ b/app/main.py @@ -431,7 +431,10 @@ def exporter_courses(statut: Optional[str] = Query(None, pattern="^(a_faire|fait @api.post("/courses/synchroniser") def synchroniser_courses(jours: int = Query(14, ge=1, le=30)): - """Cree une course par fil de discussion classe Tunis. Un fil supprime ou deja importe n'est pas recree.""" + """Cree une course par fil classe Tunis, seulement si les regles automatiques sont reactivees (eteintes par defaut).""" + from app.classifier import regles_auto_actives + if not regles_auto_actives(): + return {"ajoutees": 0, "courses": [], "regles_auto": False} from datetime import date as _date, timedelta from app.suivi import sujet_normalise fin = _date.fromisoformat(get_tunis_now_iso()[:10]) @@ -681,4 +684,5 @@ def confirm_rule_endpoint(regle_id: int): api.include_router(creer_routeur(mirror_client)) api.include_router(_analyse.creer_routeur(mirror_client)) +api.include_router(_analyse._routeur_regles_auto()) app.include_router(api) diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..eda1b32 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,3 @@ +[pytest] +markers = + regles_off: moteur de regles automatiques laisse eteint (defaut reel) diff --git a/tests/conftest.py b/tests/conftest.py index 5e17088..3ae1e68 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -50,3 +50,12 @@ def client(valid_jwt_token, temp_db, monkeypatch): with TestClient(app) as c: c.headers.update({"Cf-Access-Jwt-Assertion": valid_jwt_token}) yield c + + +@pytest.fixture(autouse=True) +def _regles_auto_pour_tests_historiques(request, monkeypatch): + """Les tests historiques verifient le moteur de regles : ils le tiennent allume. + Le reglage reel est eteint par defaut (test_regles_auto_off.py, marqueur regles_off).""" + if request.node.get_closest_marker("regles_off"): + return + monkeypatch.setattr("app.classifier.regles_auto_actives", lambda db_path=None: True) diff --git a/tests/test_regles_auto_off.py b/tests/test_regles_auto_off.py new file mode 100644 index 0000000..40f85bd --- /dev/null +++ b/tests/test_regles_auto_off.py @@ -0,0 +1,37 @@ +import pytest +from app import classifier as c +from app.db import add_regle, get_classement + +pytestmark = pytest.mark.regles_off + + +def _mail(mid="m1", objet="Course Tunis demain", exp="collegue@tt.tn"): + return {"message_id": mid, "objet": objet, "expediteur": exp, "apercu": "", "etiquettes": ["tunis"]} + + +def test_defaut_eteint(temp_db): + assert c.regles_auto_actives(temp_db) is False + + +def test_aucune_regle_ne_classe(temp_db): + add_regle(categorie="Tunis", expediteur="collegue@tt.tn", mot_cle="tunis", statut="active", db_path=temp_db) + r = c.classify_mail(_mail(), db_path=temp_db) + assert r["categorie"] == "À classer" + + +def test_reactivation_reversible(temp_db): + add_regle(categorie="Tunis", expediteur=None, mot_cle="tunis", statut="active", db_path=temp_db) + c.regler_regles_auto(True, temp_db) + assert c.classify_mail(_mail("m2"), db_path=temp_db)["categorie"] == "Tunis" + c.regler_regles_auto(False, temp_db) + assert c.classify_mail(_mail("m3"), db_path=temp_db)["categorie"] == "À classer" + + +def test_correction_manuelle_ne_propose_pas_de_regle(temp_db): + cl, regle = c.manual_classify_and_propose("m4", "Tunis", {"expediteur": "a@b.tn", "objet": "Course Tunis"}, db_path=temp_db) + assert cl["source"] == "manuel" and regle is None + + +def test_manuel_jamais_ecrase(temp_db): + c.manual_classify_and_propose("m5", "Pb PO", {"expediteur": "a@b.tn", "objet": "x"}, db_path=temp_db) + assert c.classify_mail(_mail("m5"), db_path=temp_db)["categorie"] == "Pb PO"