Files
courrier/app/mirror_client.py
T

339 lines
15 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import json
import threading
from datetime import date, timedelta
import time
from collections import deque
from typing import Optional, Dict, Any, List
import urllib.request
import urllib.error
from app.config import MIRROR_URL, read_mirror_token
class MirrorClient:
# Le miroir renvoie au plus 100 mails par lecture : toutes les vues partagent donc une seule clé de cache.
MIRROR_MAX_LATEST = 100
def __init__(self, base_url: Optional[str] = None, token: Optional[str] = None, cache_ttl_seconds: int = 60):
self.base_url = (base_url or MIRROR_URL).rstrip("/")
self._token = token or read_mirror_token()
self.session_id: Optional[str] = None
self.cache_ttl = cache_ttl_seconds
self._cache: Dict[str, tuple[float, Any]] = {}
self._call_times: deque = deque()
self._request_counter = 0
self._lock = threading.Lock()
self._refresh_started = False
self._fen_cache: Dict[tuple, tuple] = {}
self.fenetre_ttl = 600
def _check_rate_limit(self) -> None:
"""Applique strictement la limite de 60 requêtes par minute."""
now = time.time()
while self._call_times and now - self._call_times[0] > 60:
self._call_times.popleft()
if len(self._call_times) >= 60:
sleep_needed = 60.0 - (now - self._call_times[0]) + 0.1
if sleep_needed > 0:
time.sleep(sleep_needed)
self._call_times.append(time.time())
def _get_headers(self) -> Dict[str, str]:
headers = {
"Authorization": f"Bearer {self._token}",
"Content-Type": "application/json",
"Accept": "application/json, text/event-stream"
}
if self.session_id:
headers["mcp-session-id"] = self.session_id
return headers
def _initialize_session(self) -> None:
"""Initialise la session Streamable HTTP auprès de o365-mirror-mcp."""
self._check_rate_limit()
payload = {
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {},
"clientInfo": {"name": "courrier", "version": "1.0"}
}
}
headers = {
"Authorization": f"Bearer {self._token}",
"Content-Type": "application/json",
"Accept": "application/json, text/event-stream"
}
req = urllib.request.Request(self.base_url, headers=headers, data=json.dumps(payload).encode("utf-8"))
try:
with urllib.request.urlopen(req, timeout=15) as resp:
sess_id = resp.headers.get("mcp-session-id")
if not sess_id:
# Certains serveurs mettent MCP-Session-Id ou mcp-session-id
for k, v in resp.headers.items():
if k.lower() == "mcp-session-id":
sess_id = v
break
self.session_id = sess_id
except Exception as e:
raise ConnectionError(f"Échec initialisation session MCP miroir: {e}")
def call_tool(self, tool_name: str, arguments: Optional[Dict[str, Any]] = None, use_cache: bool = True, force: bool = False) -> Any:
"""Appel d'un outil du miroir : cache d'abord (sauf force), réseau sérialisé par un verrou
(la tâche de fond et les requêtes ne partagent jamais la session en même temps)."""
arguments = arguments or {}
cache_key = f"{tool_name}:{json.dumps(arguments, sort_keys=True)}"
if use_cache and not force and cache_key in self._cache:
ts, val = self._cache[cache_key]
if time.time() - ts < self.cache_ttl:
return val
with self._lock:
return self._appel_reseau(tool_name, arguments, use_cache, cache_key, force)
def _appel_reseau(self, tool_name: str, arguments: Dict[str, Any], use_cache: bool, cache_key: str, force: bool) -> Any:
now = time.time()
if use_cache and not force and cache_key in self._cache:
ts, val = self._cache[cache_key]
if now - ts < self.cache_ttl:
return val
if not self.session_id:
self._initialize_session()
self._check_rate_limit()
self._request_counter += 1
req_id = self._request_counter
payload = {
"jsonrpc": "2.0",
"id": req_id,
"method": "tools/call",
"params": {
"name": tool_name,
"arguments": arguments
}
}
data_bytes = json.dumps(payload).encode("utf-8")
req = urllib.request.Request(self.base_url, headers=self._get_headers(), data=data_bytes)
try:
with urllib.request.urlopen(req, timeout=20) as resp:
raw_body = resp.read().decode("utf-8")
except urllib.error.HTTPError as e:
# 404 = session MCP inconnue du miroir (redémarrage du miroir) : on en rouvre une et on rejoue l’appel une fois.
if (e.code == 400 and not self.session_id) or e.code == 404:
self.session_id = None
self._initialize_session()
req = urllib.request.Request(self.base_url, headers=self._get_headers(), data=data_bytes)
with urllib.request.urlopen(req, timeout=20) as resp:
raw_body = resp.read().decode("utf-8")
else:
raise
# Parsing de la réponse (peut être SSE text/event-stream ou JSON direct)
result_data = None
for line in raw_body.split("\n"):
line = line.strip()
if line.startswith("data: "):
try:
parsed = json.loads(line[6:])
result_data = parsed.get("result", {})
break
except Exception:
continue
elif line.startswith("{") and line.endswith("}"):
try:
parsed = json.loads(line)
if "result" in parsed:
result_data = parsed["result"]
break
except Exception:
continue
if not result_data:
result_data = {}
# Les outils MCP renvoient content: [{"type": "text", "text": "..."}]
content = result_data.get("content", [])
final_output = None
if content and isinstance(content, list) and "text" in content[0]:
text_val = content[0]["text"]
try:
final_output = json.loads(text_val)
except Exception:
final_output = text_val
else:
final_output = result_data
if use_cache:
self._cache[cache_key] = (now, final_output)
return final_output
def get_status(self) -> Dict[str, Any]:
"""Consulte l'état du miroir (mirror_status)."""
res = self.call_tool("mirror_status", {}, use_cache=False)
return res if isinstance(res, dict) else {"raw": res}
def get_latest_mails(self, folder: str = "*", n: int = 20, inclure_exclus: bool = False) -> List[Dict[str, Any]]:
"""Récupère les derniers emails (mirror_mail_latest)."""
res = self.call_tool("mirror_mail_latest", {
"folder": folder,
"n": min(n, self.MIRROR_MAX_LATEST),
"inclure_exclus": inclure_exclus
})
if isinstance(res, dict) and "donnees" in res:
return res["donnees"]
return res if isinstance(res, list) else []
def get_table_mails(self, requete: str = "*", n: int = 20, inclure_exclus: bool = False) -> List[Dict[str, Any]]:
"""Vue tabulaire des emails (mirror_mail_table)."""
res = self.call_tool("mirror_mail_table", {
"requete": requete,
"n": n,
"inclure_exclus": inclure_exclus
})
if isinstance(res, dict) and "donnees" in res:
return res["donnees"]
return res if isinstance(res, list) else []
def get_mails_by_tag(self, etiquette: str, periode: Optional[str] = None, n: int = 20, inclure_exclus: bool = False) -> List[Dict[str, Any]]:
"""Recherche par étiquette du miroir (mirror_mail_by_tag)."""
args: Dict[str, Any] = {"etiquette": etiquette, "n": n, "inclure_exclus": inclure_exclus}
if periode:
args["periode"] = periode
res = self.call_tool("mirror_mail_by_tag", args)
if isinstance(res, dict) and "donnees" in res:
return res["donnees"]
return res if isinstance(res, list) else []
def get_mail(self, message_id: str) -> Dict[str, Any]:
"""Récupère le détail d'un email (mirror_mail_get)."""
res = self.call_tool("mirror_mail_get", {"message_id": message_id})
return res if isinstance(res, dict) else {"raw": res}
@staticmethod
def _norm(m: Dict[str, Any]) -> Dict[str, Any]:
return {
"message_id": m.get("message_id") or m.get("id") or m.get("hash"),
"date": m.get("date") or m.get("date_reception") or m.get("date_heure") or "",
"expediteur": m.get("from") or m.get("expediteur") or "",
"objet": m.get("sujet") or m.get("subject") or m.get("objet") or "",
"etiquettes": m.get("tags") or m.get("etiquettes") or [],
"apercu": m.get("snippet") or m.get("apercu") or "",
"dossier": m.get("dossier") or "",
"destinataires": m.get("destinataires") or "",
}
@staticmethod
def _jour_suivant(jour: str) -> str:
return (date.fromisoformat(jour) + timedelta(days=1)).isoformat()
def _liste(self, res: Any) -> List[Dict[str, Any]]:
if isinstance(res, dict):
res = res.get("donnees")
return res if isinstance(res, list) else []
def mails_fenetre(self, debut: str, fin: str) -> List[Dict[str, Any]]:
"""Mails reçus de debut (inclus) à fin (exclu), AAAA-MM-JJ, au-delà des 100 derniers.
Recherche par fenêtres de dates (le miroir plafonne à 100 résultats) : une fenêtre pleine est coupée en deux.
La recherche « e » couvre presque tout ; les mails sans objet, qu'elle manque, viennent de l'étiquette sans_objet."""
cle = (debut, fin)
hit = self._fen_cache.get(cle)
if hit and time.time() - hit[0] < self.fenetre_ttl:
return hit[1]
d0, d1 = date.fromisoformat(debut), date.fromisoformat(fin)
if d1 <= d0:
return []
rows = self._liste(self.call_tool("mirror_mail_search", {"q": "e", "since": debut, "until": fin, "n": self.MIRROR_MAX_LATEST, "inclure_exclus": False}, use_cache=False))
if len(rows) >= self.MIRROR_MAX_LATEST and (d1 - d0).days > 1:
milieu = (d0 + timedelta(days=(d1 - d0).days // 2)).isoformat()
out = self.mails_fenetre(debut, milieu) + self.mails_fenetre(milieu, fin)
else:
out = list(rows)
out += self._liste(self.call_tool("mirror_mail_by_tag", {"etiquette": "sans_objet", "periode": f"{debut}..{(d1 - timedelta(days=1)).isoformat()}", "n": self.MIRROR_MAX_LATEST, "inclure_exclus": False}, use_cache=False))
vus, uniques = set(), []
for m in out:
mid = m.get("message_id")
if mid and mid not in vus:
vus.add(mid)
uniques.append(m)
if len(self._fen_cache) > 64:
self._fen_cache.clear()
self._fen_cache[cle] = (time.time(), uniques)
return uniques
def _mails_depuis(self, debut: str, max_items: int) -> List[Dict[str, Any]]:
"""Derniers mails (cache partagé) complétés par des fenêtres de dates quand la lecture de 100 ne remonte pas jusqu'à debut."""
brut = self.get_latest_mails(folder="*", n=max_items)
out = [self._norm(m) for m in brut if (self._norm(m)["date"][:10] >= debut)]
if len(brut) >= self.MIRROR_MAX_LATEST:
plus_ancien = min((self._norm(m)["date"][:10] for m in brut if self._norm(m)["date"]), default="")
if plus_ancien and plus_ancien > debut:
vus = {m["message_id"] for m in out}
etendu = False
try:
for m in self.mails_fenetre(debut, self._jour_suivant(plus_ancien)):
n = self._norm(m)
if n["message_id"] not in vus and n["date"][:10] >= debut:
vus.add(n["message_id"])
out.append(n)
etendu = True
if etendu:
out.sort(key=lambda m: m["date"], reverse=True)
except Exception:
pass # le miroir reste lisible sur les 100 derniers même si la recherche échoue
return out
def get_sent_mails(self, n: int = 100) -> List[Dict[str, Any]]:
"""Derniers messages envoyés (dossier « Messages envoyés » du miroir), normalisés."""
res = self.call_tool("mirror_mail_latest", {"folder": "Messages envoyés", "n": min(n, self.MIRROR_MAX_LATEST), "inclure_exclus": False})
return [self._norm(m) for m in self._liste(res)]
def rechercher(self, q: str, since: Optional[str] = None, until: Optional[str] = None, n: int = 100) -> List[Dict[str, Any]]:
"""Recherche plein texte du miroir (mirror_mail_search), tous dossiers, mails bruts."""
args: Dict[str, Any] = {"q": q, "n": min(n, self.MIRROR_MAX_LATEST), "inclure_exclus": False}
if since:
args["since"] = since
if until:
args["until"] = until
return self._liste(self.call_tool("mirror_mail_search", args))
def get_attachment(self, message_id: str, filename: str) -> Dict[str, Any]:
"""Pièce jointe d'un mail (mirror_mail_attachment), jamais mise en cache (contenu volumineux)."""
res = self.call_tool("mirror_mail_attachment", {"message_id": message_id, "filename": filename}, use_cache=False)
return res if isinstance(res, dict) else {"raw": res}
def get_mails_for_day(self, date_str: str, max_items: int = 50) -> List[Dict[str, Any]]:
"""Mails d'un jour donné (AAAA-MM-JJ)."""
if not date_str:
return [self._norm(m) for m in self.get_latest_mails(folder="*", n=max_items)]
return [m for m in self._mails_depuis(date_str, max_items) if date_str in m["date"]]
def get_mails_since(self, debut: str, max_items: int = 400) -> List[Dict[str, Any]]:
"""Mails dont la date est >= debut (AAAA-MM-JJ)."""
return self._mails_depuis(debut, max_items)[:max_items]
def rafraichir_derniers(self) -> None:
"""Relit les derniers mails en ignorant le cache (même clé que les vues)."""
self.call_tool("mirror_mail_latest", {"folder": "*", "n": self.MIRROR_MAX_LATEST, "inclure_exclus": False}, force=True)
def demarrer_rafraichissement(self, intervalle: int = 45) -> None:
"""Préchauffe le cache puis le rafraîchit en tâche de fond (1 lecture toutes les 45 s, loin des 60 par minute),
pour que l'ouverture d'une vue n'attende jamais le miroir. Idempotent."""
if self._refresh_started:
return
self._refresh_started = True
def boucle() -> None:
while True:
try:
self.rafraichir_derniers()
except Exception:
pass # le cache expire seul et la requête suivante relira le miroir
time.sleep(intervalle)
threading.Thread(target=boucle, name="miroir-rafraichissement", daemon=True).start()