Family filter (Detectors and LLM) and target selection for the detectors (cibles parameter of /api/detecteurs, the other sensors discarded). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
258 lines
9.4 KiB
Python
258 lines
9.4 KiB
Python
"""La web app : API/.venv/bin/python app/serveur/serveur.py → http://127.0.0.1:8770
|
|
|
|
Le serveur FastAPI sert la page React construite (app/web/dist, `npm run build` dans app/web) et l'API sous /api.
|
|
La page Support pilote les agents de API/ (API/support/seance.py).
|
|
Une séance à la fois, en mémoire ; /api/flux pousse à la page les événements des agents (server-sent events).
|
|
La page Data lit data/ et les étiquettes de labeling/ (station.py).
|
|
Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_CASES (séances), AIMSIGHT_PORT (port, 8770).
|
|
"""
|
|
import asyncio
|
|
import base64
|
|
import json
|
|
import os
|
|
import platform
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
import webbrowser
|
|
from pathlib import Path
|
|
|
|
import uvicorn
|
|
from fastapi import FastAPI, Query, Request
|
|
from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
|
|
|
|
import libredesk
|
|
import station
|
|
from fastapi.staticfiles import StaticFiles
|
|
|
|
APP = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(APP.parent / "API" / "support")) # les agents du support
|
|
from seance import Seance, donnees_par_defaut # noqa: E402
|
|
|
|
PORT = int(os.environ.get("AIMSIGHT_PORT", 8770))
|
|
HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit ni mails ni PDF
|
|
PAGE = APP / "web" / "dist"
|
|
CLIENT = None # le client Anthropic des séances ; None : le vrai (check.py y met un faux)
|
|
verrou = threading.Lock()
|
|
etat = {"seance": None, "evenements": []}
|
|
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
|
|
|
|
|
|
def journal(e: dict) -> None:
|
|
with verrou:
|
|
etat["evenements"].append(e)
|
|
|
|
|
|
def en_fond(f, *args):
|
|
def lancer():
|
|
try:
|
|
f(*args)
|
|
except Exception as e: # noqa: BLE001 — une erreur de la séance s'affiche dans la page, le serveur continue
|
|
journal({"agent": "support", "type": "erreur", "texte": f"{type(e).__name__}: {e}"})
|
|
threading.Thread(target=lancer, daemon=True).start()
|
|
|
|
|
|
def erreur(code: int, texte: str) -> JSONResponse:
|
|
return JSONResponse({"erreur": texte}, code)
|
|
|
|
|
|
@app.middleware("http")
|
|
async def garde(request: Request, suite):
|
|
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
|
|
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
|
|
hote = request.headers.get("host", "").rsplit(":", 1)[0]
|
|
if hote not in HOTES or (request.method in ("POST", "PUT", "DELETE")
|
|
and not request.headers.get("content-type", "").startswith("application/json")):
|
|
return erreur(403, "requête refusée")
|
|
return await suite(request)
|
|
|
|
|
|
def instantane(depuis: int) -> dict:
|
|
s = etat["seance"]
|
|
with verrou:
|
|
evs, n = etat["evenements"][depuis:], len(etat["evenements"])
|
|
v = s.derniere_version() if s else None
|
|
return {"evenements": evs, "n": n, "cout": s.cout() if s else None, "version": v.name if v else None,
|
|
"dossier": s.dossier.name if s else None, "id": s.id if s else None,
|
|
"station": s.station if s else None, "sortie": s.sortie if s else None,
|
|
"occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}}
|
|
|
|
|
|
@app.get("/api/flux")
|
|
async def flux(request: Request):
|
|
"""Un message à chaque changement : les nouveaux événements et l'état de la séance. Une nouvelle séance repart de
|
|
zéro (son id change) : la page vide alors ses fils."""
|
|
async def messages():
|
|
n, id_vu, dernier, calme = 0, None, None, 0
|
|
while not await request.is_disconnected():
|
|
s = etat["seance"]
|
|
if s and s.id != id_vu:
|
|
n, id_vu = 0, s.id
|
|
m = instantane(n)
|
|
reste = {k: v for k, v in m.items() if k != "evenements"}
|
|
if m["evenements"] or reste != dernier or dernier is None:
|
|
m["depuis"] = n # 0 : tout l'historique de la séance, la page remplace ses fils au lieu d'ajouter
|
|
n, dernier, calme = m["n"], reste, 0
|
|
yield f"data: {json.dumps(m, ensure_ascii=False)}\n\n"
|
|
elif (calme := calme + 1) >= 60: # ~15 s sans rien : un commentaire garde la connexion ouverte
|
|
calme = 0
|
|
yield ": calme\n\n"
|
|
await asyncio.sleep(0.25)
|
|
return StreamingResponse(messages(), media_type="text/event-stream", headers={"Cache-Control": "no-cache"})
|
|
|
|
|
|
@app.get("/api/pdf")
|
|
def pdf():
|
|
s = etat["seance"]
|
|
v = s.derniere_version() if s else None
|
|
if not v or v.suffix != ".pdf":
|
|
return erreur(404, "pas encore de PDF")
|
|
return FileResponse(v, media_type="application/pdf", filename=f"{s.dossier.name}_{v.name}",
|
|
content_disposition_type="inline")
|
|
|
|
|
|
@app.get("/api/mail")
|
|
def mail():
|
|
s = etat["seance"]
|
|
v = s.derniere_version() if s else None
|
|
if not v or v.suffix != ".json":
|
|
return erreur(404, "pas encore de mail")
|
|
return json.loads(v.read_text())
|
|
|
|
|
|
@app.get("/api/piece/{nom}")
|
|
def piece(nom: str, telecharger: bool = False):
|
|
"""Une pièce jointe du mail : seulement un fichier que cite la dernière version."""
|
|
s = etat["seance"]
|
|
v = s.derniere_version() if s else None
|
|
if not v or v.suffix != ".json" or nom not in json.loads(v.read_text())["pieces_jointes"]:
|
|
return erreur(404, "pièce inconnue")
|
|
return FileResponse(s.dossier / nom, filename=nom, content_disposition_type="attachment" if telecharger else "inline")
|
|
|
|
|
|
@app.post("/api/analyser")
|
|
def analyser(corps: dict):
|
|
s = etat["seance"]
|
|
if s and (s.occupe("support") or s.occupe("analyste")):
|
|
return erreur(409, "une séance travaille encore")
|
|
if not corps.get("mail", "").strip():
|
|
return erreur(400, "le mail est vide")
|
|
if corps.get("sortie", "pdf") not in ("pdf", "mail"):
|
|
return erreur(400, "sortie : pdf ou mail")
|
|
images = [(i["type"], base64.b64decode(i["base64"])) for i in corps.get("images", [])]
|
|
s = Seance(corps["mail"], images, corps.get("contexte", ""), donnees_par_defaut(), journal, client=CLIENT,
|
|
sortie=corps.get("sortie", "pdf"))
|
|
with verrou:
|
|
etat["seance"], etat["evenements"] = s, []
|
|
en_fond(s.demarrer)
|
|
return {"dossier": s.dossier.name}
|
|
|
|
|
|
@app.post("/api/message")
|
|
def message(corps: dict):
|
|
s, agent, texte = etat["seance"], corps.get("agent"), corps.get("texte", "").strip()
|
|
if not s:
|
|
return erreur(400, "pas de séance : coller un mail et Analyser")
|
|
if agent not in ("support", "analyste") or not texte:
|
|
return erreur(400, "agent ou texte manquant")
|
|
if s.occupe(agent):
|
|
return erreur(409, f"{agent} occupé")
|
|
en_fond(s.parler, agent, texte)
|
|
return {}
|
|
|
|
|
|
# --- les mails de LibreDesk (libredesk.py), pour remplir la page Support
|
|
|
|
@app.get("/api/libredesk")
|
|
def libredesk_liste():
|
|
try:
|
|
return libredesk.conversations()
|
|
except Exception as e: # noqa: BLE001 — non configuré ou injoignable : le dire dans la page
|
|
return erreur(502, f"LibreDesk : {e}")
|
|
|
|
|
|
@app.get("/api/libredesk/{uuid}")
|
|
def libredesk_conversation(uuid: str):
|
|
try:
|
|
return libredesk.conversation(uuid)
|
|
except Exception as e: # noqa: BLE001
|
|
return erreur(502, f"LibreDesk : {e}")
|
|
|
|
|
|
# --- la page Data (station.py)
|
|
|
|
@app.exception_handler(station.Refus)
|
|
def refus(_, e):
|
|
return erreur(400, str(e))
|
|
|
|
|
|
@app.get("/api/stations")
|
|
def stations():
|
|
return station.stations()
|
|
|
|
|
|
@app.get("/api/images")
|
|
def images(station_: str = Query(alias="station"), du: str = "", au: str = ""):
|
|
return station.images(station_, du, au)
|
|
|
|
|
|
@app.get("/api/image/{station_}/{nom}")
|
|
def image(station_: str, nom: str):
|
|
return FileResponse(station.image(station_, nom), headers={"Cache-Control": "max-age=86400"})
|
|
|
|
|
|
@app.get("/api/courbes")
|
|
def courbes(station_: str = Query(alias="station"), du: str = "", au: str = ""):
|
|
return station.courbes(station_, du, au)
|
|
|
|
|
|
@app.get("/api/detecteurs")
|
|
def detecteurs(station_: str = Query(alias="station"), du: str = "", au: str = "", cibles: str = ""):
|
|
return station.detecteurs(station_, du, au, cibles)
|
|
|
|
|
|
@app.get("/api/etiquettes")
|
|
def etiquettes(station_: str = Query(alias="station"), dossier: str = "manual"):
|
|
try:
|
|
return station.lire(station_, dossier)
|
|
except json.JSONDecodeError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier
|
|
return erreur(500, f"labeling/{dossier}/{station_}.jsonl illisible : {e}")
|
|
|
|
|
|
@app.post("/api/etiquettes")
|
|
def ajouter(corps: dict):
|
|
return station.ajouter(corps)
|
|
|
|
|
|
@app.put("/api/etiquettes")
|
|
def modifier(corps: dict):
|
|
return station.modifier(corps)
|
|
|
|
|
|
@app.delete("/api/etiquettes")
|
|
def supprimer(corps: dict):
|
|
return station.supprimer(corps)
|
|
|
|
|
|
if PAGE.is_dir():
|
|
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
|
|
else:
|
|
@app.get("/")
|
|
def sans_page():
|
|
return erreur(503, "la page n'est pas construite : cd app/web && npm install && npm run build")
|
|
|
|
|
|
def ouvrir(url: str) -> None:
|
|
if "microsoft" in platform.uname().release.lower(): # WSL : le navigateur Windows
|
|
subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
|
else:
|
|
webbrowser.open(url)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
url = f"http://127.0.0.1:{PORT}"
|
|
print(f"Support AIMsight : {url}")
|
|
if "--sans-navigateur" not in sys.argv:
|
|
threading.Timer(1, ouvrir, [url]).start()
|
|
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)
|