epreuve de lecture de captures

aides/_epreuve_texte.py

@@ -0,0 +1,158 @@
+# Le vrai regime d'usage : lire une CAPTURE D'ECRAN.
+#
+# Les 7/7 precedents portaient sur de la geometrie -- couleurs, comptage,
+# lateralite. Ils prouvent que le pipeline d'image est correctement cable, PAS
+# que le modele sait lire un terminal a 14 px. Ce sont deux regimes differents,
+# et c'est le second que Claude Code lui envoie.
+#
+# Tailles volontairement realistes : 1200x400 en monospace 15-16 px, soit la
+# densite d'une vraie fenetre. A patch 16, ca fait 75x25 = 1875 patchs, sous
+# les 2304 positions du config -- l'image n'est donc pas redimensionnee a la
+# baisse, ce qui fausserait le test dans le bon sens.
+import base64
+import io
+import json
+import os
+import subprocess
+
+from PIL import Image, ImageDraw, ImageFont
+
+PONT = "http://127.0.0.1:8080/v1/messages"
+
+PISTES = [
+    "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
+    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+    "/usr/share/fonts/dejavu/DejaVuSansMono.ttf",
+    "/opt/conda/lib/python3.12/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono.ttf",
+]
+
+
+def police(taille):
+    for p in PISTES:
+        if os.path.exists(p):
+            return ImageFont.truetype(p, taille)
+    for racine, _, fichiers in os.walk("/usr/share/fonts"):
+        for f in fichiers:
+            if f.endswith((".ttf", ".otf")):
+                return ImageFont.truetype(os.path.join(racine, f), taille)
+    return ImageFont.load_default()
+
+
+def rendre(lignes, larg=1200, haut=400, fond=(30, 30, 35), encre=(220, 220, 220),
+           taille=16, x0=24, y0=20, interligne=26):
+    img = Image.new("RGB", (larg, haut), fond)
+    d = ImageDraw.Draw(img)
+    f = police(taille)
+    for i, (txt, couleur) in enumerate(lignes):
+        d.text((x0, y0 + i * interligne), txt, font=f, fill=couleur or encre)
+    tampon = io.BytesIO()
+    img.save(tampon, format="PNG")
+    return base64.b64encode(tampon.getvalue()).decode()
+
+
+def demande(b64, texte, maxtok=200):
+    corps = {"model": "flashnext", "max_tokens": maxtok,
+             "thinking": {"type": "disabled"},
+             "messages": [{"role": "user", "content": [
+                 {"type": "image", "source": {"type": "base64",
+                  "media_type": "image/png", "data": b64}},
+                 {"type": "text", "text": texte}]}]}
+    p = subprocess.run(["curl", "-s", "-m", "180",
+                        "-H", "content-type: application/json",
+                        "-H", "anthropic-version: 2023-06-01",
+                        "-H", "x-api-key: x",
+                        "-d", json.dumps(corps), PONT],
+                       capture_output=True, text=True)
+    try:
+        d = json.loads(p.stdout)
+        if d.get("type") != "message":
+            return "ERREUR " + json.dumps(d)[:140], 0
+        t = "".join(b.get("text", "") for b in d.get("content", []))
+        return t.strip().replace("\n", " ⏎ "), d["usage"]["input_tokens"]
+    except Exception:
+        return "ILLISIBLE " + (p.stdout or "")[:120], 0
+
+
+score = 0
+total = 0
+print("   police :", police(16).path if hasattr(police(16), "path") else "defaut bitmap")
+print()
+
+# --- 1. erreur de compilation dans un terminal sombre
+b64 = rendre([
+    ("$ npm run build", (120, 220, 120)),
+    ("", None),
+    ("ERROR in src/services/auth.ts:142:18", (240, 90, 90)),
+    ("TS2345: Argument of type 'string | undefined' is not", None),
+    ("assignable to parameter of type 'string'.", None),
+    ("", None),
+    ("  140 |   const token = readToken();", (150, 150, 150)),
+    ("  141 |   if (!token) return null;", (150, 150, 150)),
+    ("> 142 |   return verify(token, secret);", None),
+    ("      |                  ^^^^^", (240, 90, 90)),
+])
+r, n = demande(b64, "Donne exactement : le code d'erreur TypeScript, le fichier, et le numero de ligne. Format : CODE | FICHIER | LIGNE")
+ok = ("TS2345" in r) and ("auth.ts" in r) and ("142" in r)
+score += ok; total += 1
+print("   1. erreur de build (%s jetons)" % n)
+print("      -> %s" % r[:170])
+print("      %s  (attendu TS2345 | src/services/auth.ts | 142)" % ("OK" if ok else "ECHEC"))
+print()
+
+# --- 2. extrait de code sur fond clair
+b64 = rendre([
+    ("def fibonacci(n: int) -> int:", (20, 20, 20)),
+    ("    if n <= 1:", (20, 20, 20)),
+    ("        return n", (20, 20, 20)),
+    ("    return fibonacci(n - 1) + fibonacci(n - 2)", (20, 20, 20)),
+    ("", None),
+    ("MAX_DEPTH = 4096", (20, 20, 20)),
+], fond=(250, 250, 250), encre=(20, 20, 20))
+r, n = demande(b64, "Quel est le nom de la fonction, et quelle est la valeur de la constante ? Reponds : NOM = ..., CONSTANTE = ...")
+ok = ("fibonacci" in r.lower()) and ("4096" in r)
+score += ok; total += 1
+print("   2. extrait de code (%s jetons)" % n)
+print("      -> %s" % r[:170])
+print("      %s  (attendu fibonacci / 4096)" % ("OK" if ok else "ECHEC"))
+print()
+
+# --- 3. transcription exacte, petite taille (13 px : densite reelle)
+b64 = rendre([
+    ("Traceback (most recent call last):", (240, 120, 120)),
+    ('  File "/travail/pont.py", line 389, in _relayer', None),
+    ("    raise EngineDeadError(queue.Full)", None),
+    ("EngineDeadError: ple_offload/connector.py queue full", (240, 90, 90)),
+], taille=13, interligne=20, haut=200)
+r, n = demande(b64, "Transcris la DERNIERE ligne du message, mot pour mot.")
+ok = ("EngineDeadError" in r) and ("queue" in r.lower())
+score += ok; total += 1
+print("   3. transcription a 13 px (%s jetons)" % n)
+print("      -> %s" % r[:170])
+print("      %s  (attendu 'EngineDeadError: ple_offload/connector.py queue full')" % ("OK" if ok else "ECHEC"))
+print()
+
+# --- 4. disposition d'interface
+img = Image.new("RGB", (900, 300), (245, 245, 248))
+d = ImageDraw.Draw(img)
+f = police(20)
+d.rectangle([80, 110, 300, 175], fill=(210, 60, 60))
+d.text((130, 132), "Supprimer", font=f, fill=(255, 255, 255))
+d.rectangle([600, 110, 820, 175], fill=(60, 140, 220))
+d.text((650, 132), "Enregistrer", font=f, fill=(255, 255, 255))
+tampon = io.BytesIO(); img.save(tampon, format="PNG")
+b64 = base64.b64encode(tampon.getvalue()).decode()
+r, n = demande(b64, "Il y a deux boutons. Lequel est a DROITE, et de quelle couleur est-il ?")
+ok = ("enregistrer" in r.lower()) and ("bleu" in r.lower())
+score += ok; total += 1
+print("   4. disposition d'interface (%s jetons)" % n)
+print("      -> %s" % r[:170])
+print("      %s  (attendu 'Enregistrer', bleu)" % ("OK" if ok else "ECHEC"))
+print()
+
+print("   SCORE LECTURE DE CAPTURE : %d/%d" % (score, total))
+if score == total:
+    print("   -> exploitable sur des captures reelles")
+elif score >= 2:
+    print("   -> partiel : lit les gros elements, echoue sur le detail")
+else:
+    print("   -> NE SAIT PAS lire une capture, malgre 7/7 en geometrie")