Mise en forme

app.py

@@ -74,10 +74,9 @@ Pipeline :
 6) resolve_coicop_candidates([...], topn=3)
 
 Règles strictes :
-- Pour (4) et (5), UTILISE EXCLUSIVEMENT le libellé fourni par l'utilisateur (ne lis pas la réponse OFF).
-- Si le libellé est vide, effectue (4) et (5) avec une chaîne vide (pas d'indexation JSON).
-Sortie :
-- Retourne UNIQUEMENT un objet JSON valide, sans backticks, sans prose.
+- Les outils renvoient des objets Python (dict/list). Tu peux indexer directement.
+- Pour (4) et (5), utilise le libellé utilisateur (pas besoin de lire la réponse d’OFF).
+- Retourne uniquement un JSON valide (objet), sans backticks.
 """
 
 
@@ -166,7 +165,7 @@ theme = gr.themes.Soft(
 
 custom_css = """
 :root{
-  --insee-primary: #0b3d91;
+  --insee-primary: #89c2d9;
   --insee-primary-700:#0a357f;
   --insee-accent: #ff5c35;
   --insee-neutral-50:#f8fafc;

quick_deploy_agent.py

@@ -39,19 +39,18 @@ def ean_check_digit_ok(ean: str) -> bool:
 class ValidateEANTool(Tool):
     name, description = "validate_ean", "Valide un EAN/GTIN (clé GS1)."
     inputs = {"ean": {"type": "string", "description": "Code EAN/GTIN (8/12/13/14 chiffres)."}}
-    output_type = "string"
+    output_type = "dict"  # <— (facultatif)
 
-    def forward(self, ean: str) -> str:
-        import json, re
+    def forward(self, ean: str):
+        import re
         digits = re.sub(r"\D", "", ean or "")
         if len(digits) not in (8, 12, 13, 14):
-            return json.dumps({"valid": False, "normalized": digits})
+            return {"valid": False, "normalized": digits}
         total = 0
         for i, ch in enumerate(reversed(digits[:-1]), start=1):
             n = int(ch); total += n * (3 if i % 2 == 1 else 1)
         check = (10 - (total % 10)) % 10
-        return json.dumps({"valid": check == int(digits[-1]), "normalized": digits})
-
+        return {"valid": check == int(digits[-1]), "normalized": digits}
 
 # ---- OFFtoCOICOP : accepte off_payload (JSON brut) OU champs séparés ----
 class OFFtoCOICOP(Tool):
@@ -134,50 +133,38 @@ class OFFByEAN(Tool):
     name = "openfoodfacts_product_by_ean"
     description = "Open Food Facts /api/v0|v2/product/{ean} (name, brands, categories...)."
     inputs = {"ean": {"type": "string", "description": "EAN à interroger sur l'API OFF."}}
-    output_type = "string"
-    requirements = ["requests"]  # urllib3 vient via requests
+    output_type = "dict"
+    requirements = ["requests"]
 
-    def forward(self, ean: str) -> str:
-        import re, json, requests
+    def forward(self, ean: str):
+        import re, requests
         from requests.adapters import HTTPAdapter
         try:
             from urllib3.util.retry import Retry
         except Exception:
-            Retry = None  # environnement minimal
+            Retry = None
 
         def _to_list(x):
-            if x is None:
-                return []
-            if isinstance(x, list):
-                # stringifier proprement les éléments non-str
-                return [str(t).strip() for t in x if str(t).strip()]
+            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):
-                parts = [p.strip() for p in re.split(r"[,\|;]", x) if p.strip()]
-                return parts
+                return [p.strip() for p in re.split(r"[,\|;]", x) if p.strip()]
             return [str(x).strip()]
 
         def _first(*vals):
             for v in vals:
-                if isinstance(v, str) and v.strip():
-                    return v.strip()
+                if isinstance(v, str) and v.strip(): return v.strip()
             return ""
 
         code = re.sub(r"\D", "", ean or "")
         if not code:
-            return json.dumps({"ok": False, "status": 0, "code": "", "error": "EAN vide"})
+            return {"ok": False, "status": 0, "code": "", "error": "EAN vide"}
 
         sess = requests.Session()
-        sess.headers.update({
-            "User-Agent": "insee-coicop-agent/1.0",
-            "Accept": "application/json",
-        })
+        sess.headers.update({"User-Agent":"insee-coicop-agent/1.0","Accept":"application/json"})
         if Retry:
-            retry = Retry(
-                total=3, backoff_factor=0.5,
-                status_forcelist=[429, 500, 502, 503, 504],
-                allowed_methods=frozenset(["GET"]),
-                raise_on_status=False,
-            )
+            retry = Retry(total=3, backoff_factor=0.5, status_forcelist=[429,500,502,503,504],
+                          allowed_methods=frozenset(["GET"]), raise_on_status=False)
             sess.mount("https://", HTTPAdapter(max_retries=retry))
 
         urls = [
@@ -201,44 +188,30 @@ class OFFByEAN(Tool):
                 status = data.get("status", 1 if product else 0)
                 if status == 1 or product:
                     p = product or {}
-                    # Normalisation stricte des champs
                     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 = 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"))
                     brands = _first(p.get("brands"), None)
                     stores = _first(p.get("stores"), None)
-
-                    out = {
-                        "ok": True,
-                        "status": status,
-                        "status_verbose": data.get("status_verbose"),
-                        "code": code,
-                        "used_url": u,
-                        # Champs lisibles directement par le LLM
+                    return {
+                        "ok": True, "status": status, "status_verbose": data.get("status_verbose"),
+                        "code": code, "used_url": u,
                         "product_name": product_name,
-                        "categories_tags": categories_tags,     # toujours list[str]
+                        "categories_tags": categories_tags,
                         "ingredients_text": ingredients_text,
-                        "brands": brands,                       # string (OFF est souvent "brand1, brand2")
-                        "brands_list": _to_list(brands),        # list[str] pratique
-                        "stores": stores,
-                        "stores_list": _to_list(stores),
-                        # 🔑 Bloc prêt pour l'étape 3
+                        "brands": brands, "brands_list": _to_list(brands),
+                        "stores": stores, "stores_list": _to_list(stores),
                         "step3_inputs": {
                             "product_name": product_name,
                             "categories_tags": categories_tags,
                             "ingredients_text": ingredients_text,
                         },
                     }
-                    return json.dumps(out)
             except Exception as e:
                 last_err = str(e)
 
-        return json.dumps({"ok": False, "status": 0, "code": code, "error": last_err or "not found"})
+        return {"ok": False, "status": 0, "code": code, "error": last_err or "not found"}
 
 
 
@@ -246,9 +219,8 @@ class OFFByEAN(Tool):
 class RegexCOICOP(Tool):
     name, description = "coicop_regex_rules", "Règles regex → candidats COICOP."
     inputs = {"text": {"type": "string", "description": "Libellé produit (texte libre) à analyser."}}
-    output_type = "string"
+    output_type = "dict"
 
-    # précompile ici pour rester autonome
     import re as _re
     SOFT = _re.compile(r"(?:\b|^)(?:CAMEMB(?:ERT)?|BRIE|COULOMMI(?:ERS?)?|BLEU|ROQUEFORT|GORGONZ(?:OLA)?|REBLOCHON|MUNSTER)(?:\b|$)")
     PRESS = _re.compile(r"(?:\b|^)(EMMENTAL|COMTE|CANTAL|MIMOLETTE|GOUDA|EDAM|BEAUFORT|ABONDANCE|SALERS|TOMME|TOME)(?:\b|$)")
@@ -264,54 +236,73 @@ class RegexCOICOP(Tool):
         s = re.sub(r"[^A-Z0-9% ]+", " ", s)
         return re.sub(r"\s+", " ", s).strip()
 
-    def forward(self, text: str) -> str:
-        import json, re
+    def forward(self, text: str):
+        import re
         s = self._normalize_txt(text); c=[]
         if self.SOFT.search(s): c.append({"code":"01.1.4.5.2","why":"pâte molle/persillée","score":0.95})
         if self.PRESS.search(s): c.append({"code":"01.1.4.5.3","why":"pâte pressée","score":0.90})
         if self.GOAT.search(s):  c.append({"code":"01.1.4.5.4","why":"chèvre","score":0.90})
         if self.PROC.search(s):  c.append({"code":"01.1.4.5.5","why":"fondu/râpé/portions","score":0.85})
         if not c and re.search(r"\bFROMAGE\b", s): c.append({"code":"01.1.4.5","why":"générique fromage/laits caillés","score":0.6})
-        return json.dumps({"candidates": c})
+        return {"candidates": c}
 
 
 # ---- OFFtoCOICOP : normalisation locale + regex règles ----
 class OFFtoCOICOP(Tool):
-    name, description = "map_off_to_coicop", "Mappe catégories OFF vers COICOP."
+    name, description = "map_off_to_coicop", "Mappe catégories OFF vers COICOP (off_payload ou champs séparés)."
     inputs = {
         "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},
+        "off_payload":     {"type":"string","description":"Chaîne JSON brute renvoyée par l'étape 2.", "nullable": True},
     }
-    output_type="string"
-    import re as _re
-    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.85,"OFF: fondu/rapé/portions")),
-    ]
+    output_type="dict"
 
-    @staticmethod
-    def _normalize_txt(s: str) -> str:
+    import re as _re, json as _json, ast as _ast
+    def _normalize_txt(self, s: str) -> str:
         import unicodedata, re
         if not s: return ""
         s = s.upper()
         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.85,"OFF: fondu/rapé/portions")),
+    ]
+
+    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):
+            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 ""
 
-    def forward(self, product_name=None, categories_tags=None, ingredients_text=None) -> str:
-        import json
         text = " ".join([t for t in [
             self._normalize_txt(product_name or ""),
-            self._normalize_txt(" ".join(categories_tags or [])),
+            self._normalize_txt(" ".join(self._to_list(categories_tags))),
             self._normalize_txt(ingredients_text or "")
         ] if t])
+
         c=[]
         for rx,(code,score,why) in self.RULES:
             if rx.search(text): c.append({"code":code,"why":why,"score":score})
-        return json.dumps({"candidates": c})
+
+        return {"candidates": c}
 
 
 # ---- SemSim : COICOP embarqué + import lazy du modèle ----
@@ -319,11 +310,9 @@ class SemSim(Tool):
     name, description = "coicop_semantic_similarity", "Embeddings → top-k COICOP."
     inputs = {"text":{"type":"string","description":"Texte libellé"},
               "topk":{"type":"integer","description":"Nombre de candidats (défaut 5)","nullable":True}}
-    output_type = "string"
-    # packages nécessaires côté Hub
+    output_type = "dict"
     requirements = ["sentence_transformers", "torch"]
 
-    # mini référentiel embarqué pour l'export Hub
     COICOP_ITEMS = [
         {"code": "01.1.4.5.1", "label": "Laits caillés, fromage blanc, petites crèmes fromagères"},
         {"code": "01.1.4.5.2", "label": "Fromage à pâte molle et à pâte persillée"},
@@ -344,10 +333,8 @@ class SemSim(Tool):
         s = re.sub(r"[^A-Z0-9% ]+", " ", s)
         return re.sub(r"\s+", " ", s).strip()
 
-    def forward(self, text: str, topk: int = 5) -> str:
-        import json
+    def forward(self, text: str, topk: int = 5):
         from sentence_transformers import SentenceTransformer, util
-        # lazy init pour la compat hub
         if not hasattr(self, "_model"):
             self._model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
         q = self._normalize_txt(text)
@@ -360,22 +347,27 @@ class SemSim(Tool):
              for i in range(len(self.COICOP_ITEMS))],
             key=lambda x: x["score"], reverse=True
         )
-        return json.dumps({"candidates": ranked[:max(1,int(topk))]})
+        return {"candidates": ranked[:max(1,int(topk))]}
 
 
 # ---- Resolve : import local json ----
 class Resolve(Tool):
     name, description = "resolve_coicop_candidates", "Fusionne candidats → choix final + alternatives + explication."
-    inputs = {"json_lists": {"type":"array","description":"Liste de JSON (str) d'autres tools."},
+    inputs = {"json_lists": {"type":"array","description":"Liste de JSON (str/dict) d'autres tools."},
               "topn":{"type":"integer","description":"Nb d'alternatives (défaut 3)","nullable":True}}
-    output_type = "string"
+    output_type = "dict"
 
-    def forward(self, json_lists, topn: int = 3) -> str:
+    def forward(self, json_lists, topn: int = 3):
+        # accepter listes de strings JSON OU de dicts
         import json
         from typing import Dict, Any
         bucket: Dict[str, Dict[str, Any]] = {}
         for s in json_lists:
-            data = json.loads(s) if s else {}
+            data = s
+            if isinstance(s, str):
+                try: data = json.loads(s)
+                except Exception: data = {}
+            if not isinstance(data, dict): continue
             for c in data.get("candidates", []):
                 code = c["code"]; score = float(c.get("score", 0.0))
                 why = c.get("why", "") or c.get("label", "")
@@ -388,47 +380,7 @@ class Resolve(Tool):
         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 json.dumps({"final": None, "alternatives": [], "explanation":"Aucun candidat"})
+        if not ranked: return {"final": None, "alternatives": [], "explanation":"Aucun candidat"}
         final = ranked[0]; alts = ranked[1:1+max(0,int(topn))]
         exp = f"Choix {final['code']} (score {final['score_final']:.2f}) – votes={final['votes']} – raisons: {', '.join(sorted(set(final['evidences'])))}"
-        return json.dumps({"final": final, "alternatives": alts, "explanation": exp})
-
-
-
-def build_agent(model_id: str | None = None) -> CodeAgent:
-    model_id = model_id or "Qwen/Qwen2.5-Coder-7B-Instruct"  # léger pour tester
-    agent = CodeAgent(
-        tools=[ValidateEANTool(), OFFByEAN(), RegexCOICOP(), OFFtoCOICOP(), SemSim(), Resolve()],
-        model=InferenceClientModel(model_id=model_id),
-        add_base_tools=False,
-        max_steps=6,
-        verbosity_level=2,
-    )
-    return agent
-
-def parse_result(res):
-    if isinstance(res, dict): return res
-    try: return ast.literal_eval(res)
-    except Exception: return {"raw": res}
-
-if __name__ == "__main__":
-    # Remplace par les vraies données si possible - uniquement du test
-    ean = "3256221112345"  # EAN fictif (peut ne pas exister sur OFF)
-    label = "Camembert au lait cru AOP 250g - ALDI"
-
-    agent = build_agent()
-    task = f"""
-    Classe ce produit en COICOP:
-    EAN: {ean}
-    Libellé: {label}
-    Pipeline:
-    1) validate_ean(ean)
-    2) openfoodfacts_product_by_ean(ean)  # si OFF ne trouve pas, on s'appuie sur regex + embeddings
-    3) map_off_to_coicop(product_name, categories_tags, ingredients_text)
-    4) coicop_regex_rules(text=libellé)
-    5) coicop_semantic_similarity(text=libellé, topk=5)
-    6) resolve_coicop_candidates([...], topn=3)
-    Attend un JSON final.
-    """
-    out = agent.run(task)
-    print(parse_result(out))
+        return {"final": final, "alternatives": alts, "explanation": exp}