AntiCoco: serveur MCP HelloFresh sans noix de coco

- Auth Playwright (login local, session persistee, capture du bearer token)
- Client httpx vers l'API interne (endpoints via discover_api.py)
- Filtre d'exclusion insensible aux accents (coco & co)
- Serveur FastMCP (streamable-http) + outils hf_*
- Docker + compose pour deploiement homelab

hellofresh/filter.py

@@ -0,0 +1,111 @@
+"""Filtrage des recettes : exclusion d'ingrédients (coco !) + scoring par préférences.
+
+Matching insensible à la casse ET aux accents : « Noix de Coco », « noix de coco rapée »
+et « creme de coco » matchent tous l'entrée « coco ». On compare des mots normalisés sur
+le nom des ingrédients, les allergènes, le nom et le titre de la recette.
+"""
+
+from __future__ import annotations
+
+import json
+import unicodedata
+from pathlib import Path
+
+from .auth import ROOT
+from .models import Recipe
+
+EXCLUDES_PATH = ROOT / "config" / "excludes.json"
+PREFS_PATH = ROOT / "config" / "prefs.json"
+
+
+def normalize(s: str) -> str:
+    """Minuscule + suppression des accents (NFD → drop des diacritiques)."""
+    s = unicodedata.normalize("NFD", s or "")
+    s = "".join(c for c in s if unicodedata.category(c) != "Mn")
+    return s.lower().strip()
+
+
+# --- gestion de la liste d'exclusion ---------------------------------------
+def load_excludes() -> list[str]:
+    if not EXCLUDES_PATH.exists():
+        return []
+    data = json.loads(EXCLUDES_PATH.read_text(encoding="utf-8"))
+    return list(data.get("exclude", []))
+
+
+def save_excludes(terms: list[str]) -> None:
+    existing = {}
+    if EXCLUDES_PATH.exists():
+        existing = json.loads(EXCLUDES_PATH.read_text(encoding="utf-8"))
+    existing["exclude"] = terms
+    EXCLUDES_PATH.write_text(json.dumps(existing, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def add_exclude(term: str) -> list[str]:
+    terms = load_excludes()
+    if normalize(term) not in {normalize(t) for t in terms}:
+        terms.append(term)
+        save_excludes(terms)
+    return terms
+
+
+def remove_exclude(term: str) -> list[str]:
+    nt = normalize(term)
+    terms = [t for t in load_excludes() if normalize(t) != nt]
+    save_excludes(terms)
+    return terms
+
+
+def load_prefs() -> dict:
+    if not PREFS_PATH.exists():
+        return {"liked": [], "disliked": []}
+    data = json.loads(PREFS_PATH.read_text(encoding="utf-8"))
+    return {"liked": data.get("liked", []), "disliked": data.get("disliked", [])}
+
+
+# --- application aux recettes ----------------------------------------------
+def _recipe_haystack(recipe: Recipe) -> str:
+    parts = [recipe.name, recipe.headline, *recipe.ingredients, *recipe.allergens, *recipe.tags]
+    return normalize(" | ".join(p for p in parts if p))
+
+
+def mark_excluded(recipe: Recipe, excludes: list[str] | None = None) -> Recipe:
+    """Remplit `contains_excluded` et `matched_excludes` sur la recette."""
+    excludes = excludes if excludes is not None else load_excludes()
+    hay = _recipe_haystack(recipe)
+    matched = [term for term in excludes if normalize(term) and normalize(term) in hay]
+    recipe.matched_excludes = matched
+    recipe.contains_excluded = bool(matched)
+    return recipe
+
+
+def score(recipe: Recipe, prefs: dict | None = None) -> float:
+    prefs = prefs or load_prefs()
+    hay = _recipe_haystack(recipe)
+    s = 0.0
+    for kw in prefs.get("liked", []):
+        if normalize(kw) and normalize(kw) in hay:
+            s += 1.0
+    for kw in prefs.get("disliked", []):
+        if normalize(kw) and normalize(kw) in hay:
+            s -= 1.0
+    recipe.score = s
+    return s
+
+
+def annotate(recipes: list[Recipe]) -> list[Recipe]:
+    """Marque exclusions + score sur une liste de recettes (in place)."""
+    excludes = load_excludes()
+    prefs = load_prefs()
+    for r in recipes:
+        mark_excluded(r, excludes)
+        score(r, prefs)
+    return recipes
+
+
+def propose(recipes: list[Recipe], count: int | None = None) -> list[Recipe]:
+    """Retire les recettes exclues (coco…) et classe le reste par score décroissant."""
+    annotate(recipes)
+    safe = [r for r in recipes if not r.contains_excluded]
+    safe.sort(key=lambda r: r.score, reverse=True)
+    return safe[:count] if count else safe