From a9fbd4508149f98f78670cc6a4167b501b4595a4 Mon Sep 17 00:00:00 2001 From: gemini-ops Date: Tue, 17 Nov 2026 23:34:44 +0100 Subject: [PATCH] Courrier v1.4 (tt-2026-11-067) : periodes anciennes par fenetres de dates au-dela des 100 mails du miroir Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01XGaEeWkqZYNP6Wn3mGQsrL --- app/mirror_client.py | 116 ++++++++++++++++++++++++++------------ tests/test_fenetre_067.py | 83 +++++++++++++++++++++++++++ 2 files changed, 163 insertions(+), 36 deletions(-) create mode 100644 tests/test_fenetre_067.py diff --git a/app/mirror_client.py b/app/mirror_client.py index edcf55e..2480873 100644 --- a/app/mirror_client.py +++ b/app/mirror_client.py @@ -1,5 +1,6 @@ import json import threading +from datetime import date, timedelta import time from collections import deque from typing import Optional, Dict, Any, List @@ -22,6 +23,8 @@ class MirrorClient: 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.""" @@ -209,45 +212,86 @@ class MirrorClient: 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 "", + } + + @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_mails_for_day(self, date_str: str, max_items: int = 50) -> List[Dict[str, Any]]: - """ - Récupère les emails correspondant à un jour donné (date_str: AAAA-MM-JJ). - Utilise mirror_mail_latest avec un nombre suffisant de messages puis filtre par date. - """ - raw_mails = self.get_latest_mails(folder="*", n=max_items) - filtered = [] - for m in raw_mails: - # Vérifier la présence du message_id ou id - mid = m.get("message_id") or m.get("id") or m.get("hash") - d_mail = m.get("date") or m.get("date_reception") or m.get("date_heure") or "" - if date_str in d_mail or not date_str: - m_normalized = { - "message_id": mid, - "date": d_mail, - "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 "" - } - filtered.append(m_normalized) - return filtered + """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), normalisés comme get_mails_for_day.""" - out = [] - for m in self.get_latest_mails(folder="*", n=max_items): - mid = m.get("message_id") or m.get("id") or m.get("hash") - d_mail = m.get("date") or m.get("date_reception") or m.get("date_heure") or "" - if d_mail[:10] >= debut: - out.append({ - "message_id": mid, - "date": d_mail, - "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 "" - }) - return out + """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).""" diff --git a/tests/test_fenetre_067.py b/tests/test_fenetre_067.py new file mode 100644 index 0000000..6d8d051 --- /dev/null +++ b/tests/test_fenetre_067.py @@ -0,0 +1,83 @@ +import json +from app.mirror_client import MirrorClient + + +def mail(i, jour, hh="10:00:00", tags=None): + return {"message_id": f"m{i}", "dossier": "Boîte de réception", "date_reception": f"{jour}T{hh}+01:00", + "expediteur": "a@b.c", "sujet": f"s{i}", "etiquettes": tags or []} + + +class Faux(MirrorClient): + """Miroir simulé : 300 mails, 10 par jour du 01/11 au 30/11 ; latest plafonné à 100, search à 100.""" + def __init__(self): + super().__init__(base_url="http://x", token="t") + self.appels = [] + self.tous = [mail(i, f"2026-11-{1 + i // 10:02d}", f"{(i % 10) + 8:02d}:00:00") for i in range(300)] + self.tous.append(mail(999, "2026-11-05", "09:00:00", ["sans_objet"])) + self.tous[-1]["sujet"] = "" + + def call_tool(self, nom, args=None, use_cache=True, force=False): + args = args or {} + self.appels.append((nom, dict(args))) + n = min(args.get("n", 10), 100) + if nom == "mirror_mail_latest": + return {"donnees": sorted(self.tous, key=lambda m: m["date_reception"], reverse=True)[:n]} + if nom == "mirror_mail_search": + d, f = args["since"], args["until"] + r = [m for m in self.tous if d <= m["date_reception"][:10] < f and m["sujet"]] + return {"donnees": sorted(r, key=lambda m: m["date_reception"], reverse=True)[:n]} + if nom == "mirror_mail_by_tag": + d, f = args["periode"].split("..") + r = [m for m in self.tous if d <= m["date_reception"][:10] <= f and args["etiquette"] in m["etiquettes"]] + return {"donnees": r[:n]} + return {"donnees": []} + + +def test_periode_courte_sans_recherche(): + c = Faux() + r = c.get_mails_since("2026-11-26") + assert len(r) == 50 or len(r) > 0 + assert all(a[0] == "mirror_mail_latest" for a in c.appels) + + +def test_periode_longue_complete(): + c = Faux() + r = c.get_mails_since("2026-11-01", max_items=800) + ids = {m["message_id"] for m in r} + assert len(ids) == len(r) == 301 + assert "m999" in ids # mail sans objet récupéré par l'étiquette + assert [m["date"] for m in r] == sorted((m["date"] for m in r), reverse=True) + + +def test_fenetre_pleine_coupee_en_deux(): + c = Faux() + c.mails_fenetre("2026-11-01", "2026-11-30") + recherches = [a for a in c.appels if a[0] == "mirror_mail_search"] + assert len(recherches) > 1 + assert all(a[1]["n"] == 100 for a in recherches) + + +def test_cache_fenetre(): + c = Faux() + c.mails_fenetre("2026-11-01", "2026-11-12") + n1 = len(c.appels) + c.mails_fenetre("2026-11-01", "2026-11-12") + assert len(c.appels) == n1 + + +def test_echec_recherche_garde_les_100_derniers(): + c = Faux() + base = c.call_tool + def casse(nom, args=None, use_cache=True, force=False): + if nom == "mirror_mail_search": + raise ConnectionError("miroir") + return base(nom, args, use_cache, force) + c.call_tool = casse + r = c.get_mails_since("2026-11-01", max_items=800) + assert len(r) == 100 + + +def test_jour_ancien(): + c = Faux() + r = c.get_mails_for_day("2026-11-03", max_items=100) + assert len(r) == 10 and all("2026-11-03" in m["date"] for m in r)