meilleure lecture des ingrédients + nombreecho renvoyés

quick_deploy_agent.py

@@ -59,7 +59,7 @@ class OFFByEAN(Tool):
     requirements = ["requests"]
 
     def forward(self, ean: str):
-        import re
+        import re, json
         from requests.adapters import HTTPAdapter
         try:
             from urllib3.util.retry import Retry
@@ -92,8 +92,9 @@ class OFFByEAN(Tool):
         urls = [
             f"https://world.openfoodfacts.org/api/v0/product/{code}.json",
             "https://world.openfoodfacts.org/api/v2/product/"
-            f"{code}?lc=fr&fields=code,product_name,product_name_fr,brands,"
-            "categories_tags,categories_tags_fr,ingredients_text,ingredients_text_fr,"
+            f"{code}?lc=fr&fields=code,product_name,product_name_fr,brands,labels_tags,"
+            "categories_tags,categories_tags_fr,categories_hierarchy,ingredients,ingredients_text,"
+            "ingredients_text_fr,ingredients_text_en,allergens,allergens_tags,traces,traces_tags,"
             "stores,status,status_verbose",
             f"https://world.openfoodfacts.net/api/v0/product/{code}.json",
         ]
@@ -111,23 +112,51 @@ class OFFByEAN(Tool):
                 if status == 1 or product:
                     p = product or {}
                     product_name = _first(p.get("product_name_fr"), p.get("product_name"))
+
                     categories_tags = p.get("categories_tags_fr") or p.get("categories_tags") or p.get("categories")
                     categories_tags = _to_list(categories_tags)
-                    ingredients_text = _first(p.get("ingredients_text_fr"), p.get("ingredients_text"))
+                    categories_hierarchy = _to_list(p.get("categories_hierarchy"))
+
+                    # Ingrédients : texte + liste structurée
+                    ingredients_text = _first(p.get("ingredients_text_fr"), p.get("ingredients_text_en"), p.get("ingredients_text"))
+                    ingredients_list = []
+                    if isinstance(p.get("ingredients"), list):
+                        for it in p["ingredients"]:
+                            txt = it.get("text") or it.get("id") or ""
+                            if txt: ingredients_list.append(str(txt).strip())
+
+                    allergens = _first(p.get("allergens"), None)
+                    allergens_tags = _to_list(p.get("allergens_tags"))
+                    traces = _first(p.get("traces"), None)  # ex: "lait, noisettes"
+                    traces_tags = _to_list(p.get("traces_tags"))
+                    labels_tags = _to_list(p.get("labels_tags"))
+
                     brands = _first(p.get("brands"), None)
                     stores = _first(p.get("stores"), None)
+
                     return {
                         "ok": True, "status": status, "status_verbose": data.get("status_verbose"),
                         "code": code, "used_url": u,
                         "product_name": product_name,
                         "categories_tags": categories_tags,
+                        "categories_hierarchy": categories_hierarchy,
                         "ingredients_text": ingredients_text,
+                        "ingredients_list": ingredients_list,
+                        "allergens": allergens,
+                        "allergens_tags": allergens_tags,
+                        "traces": traces,
+                        "traces_tags": traces_tags,
+                        "labels_tags": labels_tags,
                         "brands": brands, "brands_list": _to_list(brands),
                         "stores": stores, "stores_list": _to_list(stores),
+                        # Entrées déjà prêtes pour l’étape 3
                         "step3_inputs": {
                             "product_name": product_name,
                             "categories_tags": categories_tags,
                             "ingredients_text": ingredients_text,
+                            "ingredients_list": ingredients_list,
+                            "traces": traces,
+                            "traces_tags": traces_tags,
                         },
                     }
             except Exception as e:
@@ -135,6 +164,7 @@ class OFFByEAN(Tool):
 
         return {"ok": False, "status": 0, "code": code, "error": last_err or "not found"}
 
+
 # ---- RegexCOICOP ----
 class RegexCOICOP(Tool):
     name, description = "coicop_regex_rules", "Règles regex → candidats COICOP."
@@ -174,6 +204,9 @@ class OFFtoCOICOP(Tool):
         "product_name":    {"type":"string", "description":"Nom produit OFF (fr/en).", "nullable": True},
         "categories_tags": {"type":"array",  "description":"Liste OFF categories_tags.", "nullable": True},
         "ingredients_text":{"type":"string","description":"Texte ingrédients.", "nullable": True},
+        "ingredients_list":{"type":"array", "description":"Liste structurée des ingrédients (strings).", "nullable": True},
+        "traces":          {"type":"string","description":"Champ traces (fr).", "nullable": True},
+        "traces_tags":     {"type":"array", "description":"Tags de traces.", "nullable": True},
         "off_payload":     {"type":"string","description":"Chaîne JSON brute renvoyée par l'étape 2.", "nullable": True},
     }
     output_type="object"
@@ -186,47 +219,119 @@ class OFFtoCOICOP(Tool):
         s = "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn")
         s = re.sub(r"[^A-Z0-9% ]+", " ", s)
         return re.sub(r"\s+", " ", s).strip()
+
     def _to_list(self, x):
         import re
         if x is None: return []
         if isinstance(x, list): return [str(t).strip() for t in x if str(t).strip()]
         if isinstance(x, str): return [p.strip() for p in re.split(r"[,\|;]", x) if p.strip()]
         return [str(x).strip()]
+
     def _safe_parse(self, s):
         try: return self._json.loads(s)
         except Exception:
             try: return self._ast.literal_eval(s)
             except Exception: return {}
 
-    RULES = [
-        (_re.compile(r"\b(CAMEMBERT|BRIE|COULOMMIERS|BLUE CHEESE|ROQUEFORT|GORGONZOLA|MUNSTER|REBLOCHON)\b"), ("01.1.4.5.2",0.95,"OFF: pâte molle/persillée")),
-        (_re.compile(r"\b(EMMENTAL|COMTE|CANTAL|MIMOLETTE|GOUDA|EDAM|BEAUFORT|ABONDANCE|SALERS|TOMME|TOME)\b"), ("01.1.4.5.3",0.90,"OFF: pâte pressée")),
-        (_re.compile(r"\b(CHEVRE|STE MAURE|CROTTIN|BUCHE|PICODON|PELARDON|BANON)\b"), ("01.1.4.5.4",0.90,"OFF: chèvre")),
-        (_re.compile(r"\b(FONDU|FONDUES?|RAPE|RÂPE|PORTIONS?|KIRI|VACHE QUI RIT|CARRE FRAIS|CARR[ÉE] FRAIS)\b"), ("01.1.4.5.5",0.88,"OFF: fondu/rapé/portions")),
-        (_re.compile(r"\b(CHEESE[ -]?SPREADS?|FROMAGE[S]?\s+FONDUS?)\b"), ("01.1.4.5.5",0.92,"OFF: cheese spreads / fromage fondu")),
-        (_re.compile(r"\b(PROCESSED[ -]?CHEESE|TOASTINETTES?)\b"), ("01.1.4.5.5",0.90,"OFF: processed cheese")),
-        (_re.compile(r"\b(FROMAGE\s+BLANC|PETITES?\s+CREMES?\s+FROMAGERES?)\b"), ("01.1.4.5.1",0.85,"OFF: fromage blanc / crèmes fromagères")),
-    ]
-
-    def forward(self, product_name=None, categories_tags=None, ingredients_text=None, off_payload=None):
-        if off_payload and not (product_name or categories_tags or ingredients_text):
+    # --- mots-clés par familles
+    SOFT  = _re.compile(r"\b(CAMEMBERT|BRIE|COULOMMIERS|BLUE CHEESE|ROQUEFORT|GORGONZOLA|MUNSTER|REBLOCHON)\b")
+    PRESS = _re.compile(r"\b(EMMENTAL|COMTE|CANTAL|MIMOLETTE|GOUDA|EDAM|BEAUFORT|ABONDANCE|SALERS|TOMME|TOME)\b")
+    GOAT  = _re.compile(r"\b(CHEVRE|CH[ÈE]VRE|STE MAURE|CROTTIN|BUCHE|BUCHETTE|PICODON|PELARDON|BANON)\b")
+    PROC  = _re.compile(r"\b(FONDU|FONDUES?|RAPE|RÂPE|PORTIONS?|KIRI|VACHE QUI RIT|CARRE FRAIS|CARR[ÉE] FRAIS|TOASTINETTES?)\b")
+    GENERIC_FROMAGE = _re.compile(r"\bFROMAGE[S]?\b")
+    CREMEUX = _re.compile(r"\bCR[ÉE]MEUX\b")
+
+    # --- suppression des clauses "traces"
+    _TRACES_BLOCK = _re.compile(
+        r"(PEUT\s+CONTENIR\s+DES\s+TRACES\s+DE\s+[^.;\)\]]+)|"
+        r"(MAY\s+CONTAIN\s+TRACES\s+OF\s+[^.;\)\]]+)|"
+        r"(\bTRACES?\s+DE\s+[^.;\)\]]+)",
+        _re.I
+    )
+
+    def _without_traces(self, s: str) -> str:
+        if not s: return ""
+        return self._TRACES_BLOCK.sub(" ", s)
+
+    def _mk(self, code, base, why, source):
+        # petit lissage par source
+        boost = {"name":0.05, "cat":0.04, "ing_no_traces":0.03, "ing":0.01}.get(source, 0.0)
+        return {"code": code, "score": round(base+boost, 4), "why": f"{why} (source:{source})"}
+
+    def forward(self, product_name=None, categories_tags=None, ingredients_text=None,
+                ingredients_list=None, traces=None, traces_tags=None, off_payload=None):
+
+        # Hydrate depuis off_payload si besoin
+        if off_payload and not (product_name or categories_tags or ingredients_text or ingredients_list or traces or traces_tags):
             data = self._safe_parse(off_payload) or {}
             product_name    = data.get("product_name") or ""
             categories_tags = self._to_list(data.get("categories_tags"))
             ingredients_text= data.get("ingredients_text") or ""
-
-        raw_cats = " ".join(self._to_list(categories_tags))
-        text = " ".join([t for t in [
-            self._normalize_txt(product_name or ""),
-            self._normalize_txt(raw_cats),
-            self._normalize_txt(ingredients_text or "")
-        ] if t])
+            ingredients_list= self._to_list(data.get("ingredients_list"))
+            traces          = data.get("traces") or ""
+            traces_tags     = self._to_list(data.get("traces_tags"))
+
+        name = self._normalize_txt(product_name or "")
+        cats = self._normalize_txt(" ".join(self._to_list(categories_tags)))
+        ingt = self._normalize_txt(ingredients_text or "")
+        ingt_no_tr = self._normalize_txt(self._without_traces(ingredients_text or ""))
+        ing_list = [self._normalize_txt(x) for x in self._to_list(ingredients_list)]
+        ing_join = " ".join(ing_list)
+        ing_join_no_tr = self._normalize_txt(self._without_traces(ing_join))
 
         c=[]
-        for rx,(code,score,why) in self.RULES:
-            if rx.search(text): c.append({"code":code,"why":why,"score":score})
 
-        return {"candidates": c}
+        # 1) Nom produit et catégories (forts)
+        if self.SOFT.search(name) or self.SOFT.search(cats):
+            c.append(self._mk("01.1.4.5.2", 0.90, "OFF: pâte molle/persillée", "name" if self.SOFT.search(name) else "cat"))
+        if self.PRESS.search(name) or self.PRESS.search(cats):
+            c.append(self._mk("01.1.4.5.3", 0.87, "OFF: pâte pressée", "name" if self.PRESS.search(name) else "cat"))
+        if self.GOAT.search(name) or self.GOAT.search(cats):
+            c.append(self._mk("01.1.4.5.4", 0.88, "OFF: chèvre", "name" if self.GOAT.search(name) else "cat"))
+        if self.PROC.search(name) or self.PROC.search(cats):
+            c.append(self._mk("01.1.4.5.5", 0.86, "OFF: fondu/râpé/portions", "name" if self.PROC.search(name) else "cat"))
+
+        # 2) Ingrédients – version SANS "traces" (moyen)
+        if self.SOFT.search(ingt_no_tr) or self.SOFT.search(ing_join_no_tr):
+            c.append(self._mk("01.1.4.5.2", 0.84, "Ingrédients (sans traces): pâte molle/persillée", "ing_no_traces"))
+        if self.PRESS.search(ingt_no_tr) or self.PRESS.search(ing_join_no_tr):
+            c.append(self._mk("01.1.4.5.3", 0.82, "Ingrédients (sans traces): pâte pressée", "ing_no_traces"))
+        if self.GOAT.search(ingt_no_tr) or self.GOAT.search(ing_join_no_tr):
+            # ⚠️ chèvre uniquement s'il n'est PAS dans des traces
+            c.append(self._mk("01.1.4.5.4", 0.83, "Ingrédients (sans traces): chèvre", "ing_no_traces"))
+        if self.PROC.search(ingt_no_tr) or self.PROC.search(ing_join_no_tr):
+            c.append(self._mk("01.1.4.5.5", 0.80, "Ingrédients (sans traces): fondu/râpé/portions", "ing_no_traces"))
+
+        # 3) Ingrédients bruts (faible, exemple ne déclenche pas chèvre seul)
+        if self.SOFT.search(ingt) or self.SOFT.search(ing_join):
+            c.append(self._mk("01.1.4.5.2", 0.78, "Ingrédients: pâte molle/persillée", "ing"))
+        if self.PRESS.search(ingt) or self.PRESS.search(ing_join):
+            c.append(self._mk("01.1.4.5.3", 0.76, "Ingrédients: pâte pressée", "ing"))
+        if self.PROC.search(ingt) or self.PROC.search(ing_join):
+            c.append(self._mk("01.1.4.5.5", 0.74, "Ingrédients: fondu/râpé/portions", "ing"))
+        # NB: volontairement pas de déclencheur chèvre ici (pour éviter les faux positifs via 'traces').
+
+        # 4) Génériques
+        if not c and (self.GENERIC_FROMAGE.search(name) or self.GENERIC_FROMAGE.search(cats)):
+            c.append(self._mk("01.1.4.5", 0.60, "OFF: générique fromage", "cat"))
+        if not c and self.CREMEUX.search(name):
+            c.append(self._mk("01.1.4.5.1", 0.58, "OFF: crémeux", "name"))
+
+        # Dédupliquer en gardant le meilleur score par code + agréger les justifs
+        bucket={}
+        for ci in c:
+            code=ci["code"]
+            if code not in bucket:
+                bucket[code] = {**ci, "why_list":[ci["why"]]}
+            else:
+                if ci["score"]>bucket[code]["score"]:
+                    bucket[code].update({"score":ci["score"], "why":ci["why"]})
+                bucket[code]["why_list"].append(ci["why"])
+
+        ranked = sorted(bucket.values(), key=lambda x: x["score"], reverse=True)
+        # Retourne TOUJOURS au moins 3 candidats (en les espaçant si besoin)
+        return {"candidates": ranked[:max(3, len(ranked))][:3]}
+
 
 # ---- SemSim ----
 class SemSim(Tool):
@@ -342,7 +447,7 @@ class Resolve(Tool):
         from typing import Dict, Any
         bucket: Dict[str, Dict[str, Any]] = {}
 
-        # Tolérance : si on passe directement une liste de candidats [{...}, {...}]
+        # Tolérance liste directe
         if isinstance(json_lists, list) and json_lists and isinstance(json_lists[0], dict) and "code" in json_lists[0]:
             json_lists = [{"candidates": json_lists}]
 
@@ -361,13 +466,24 @@ class Resolve(Tool):
                     bucket[code]["score"] = max(bucket[code]["score"], score)
                     bucket[code]["votes"] += 1
                     if why: bucket[code]["evidences"].append(why)
+
         for v in bucket.values():
             v["score_final"] = v["score"] + 0.05*(v["votes"]-1)
+
         ranked = sorted(bucket.values(), key=lambda x: x["score_final"], reverse=True)
-        if not ranked: return {"final": None, "alternatives": [], "explanation":"Aucun candidat"}
-        final = ranked[0]; alts = ranked[1:1+max(0,int(topn))]
+        if not ranked: 
+            return {"final": None, "alternatives": [], "candidates_top": [], "explanation":"Aucun candidat"}
+
+        # Top fusionné : au moins 3
+        min_top = max(3, topn if isinstance(topn, int) and topn>0 else 3)
+        top_candidates = ranked[:min_top]
+
+        final = ranked[0]
+        alts  = ranked[1:1+min_top-1]  # alternatives complémentaires pour arriver à min_top au total
         exp = f"Choix {final['code']} (score {final['score_final']:.2f}) – votes={final['votes']} – raisons: {', '.join(sorted(set(final['evidences'])))}"
-        return {"final": final, "alternatives": alts, "explanation": exp}
+
+        return {"final": final, "alternatives": alts, "candidates_top": top_candidates, "explanation": exp}
+
 
 # ---- build_agent ----
 def build_agent(model_id: str | None = None) -> CodeAgent: