| |
| """kobench v1: Google Cloud Vision DOCUMENT_TEXT_DETECTION (owner 2026-10-05). Auth: gcloud access token of the active account; quota project from env GOOGLE_CLOUD_PROJECT. Output: one block per Vision block, |
| "<|det|>text [x0, y0, x1, y1]<|/det|>" (0..999 page-normalised, same as Native) followed by the block text, so the |
| bbox metric credits Vision's block boxes. Vision has no table structure, so table slices score from text only. |
| Usage: gvision_run.py MANIFEST_JSONL IMG_ROOT OUT_JSONL [THREADS] [LIMIT]""" |
| import os, base64, json, subprocess, sys, time, urllib.request |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
| man, root, out = sys.argv[1], Path(sys.argv[2]), Path(sys.argv[3]); threads = int(sys.argv[4]) if len(sys.argv) > 4 else 8 |
| limit = int(sys.argv[5]) if len(sys.argv) > 5 else 0 |
| tok = lambda: subprocess.run(["gcloud", "auth", "print-access-token"], capture_output=True, text=True, check=True).stdout.strip() |
| TOK = [tok(), time.time()] |
| M = [json.loads(l) for l in open(man)] |
| done = {json.loads(l)["id"] for l in out.open() if not json.loads(l).get("error")} if out.exists() else set() |
| todo = [r for r in M if r["id"] not in done][: limit or None] |
| BRK = {"SPACE": " ", "SURE_SPACE": " ", "EOL_SURE_SPACE": "\n", "LINE_BREAK": "\n", "HYPHEN": "-\n"} |
| def block_text(b): |
| s = [] |
| for p in b.get("paragraphs", []): |
| for w in p.get("words", []): |
| for c in w.get("symbols", []): |
| s.append(c.get("text", "")); s.append(BRK.get(c.get("property", {}).get("detectedBreak", {}).get("type", ""), "")) |
| s.append("\n") |
| return "".join(s).strip() |
| def call(r): |
| if time.time() - TOK[1] > 2400: TOK[:] = [tok(), time.time()] |
| raw = (root / r["image"].lstrip("/")).read_bytes() |
| body = {"requests": [{"image": {"content": base64.b64encode(raw).decode()}, "features": [{"type": "DOCUMENT_TEXT_DETECTION"}], |
| "imageContext": {"languageHints": ["ko"]}}]} |
| req = urllib.request.Request("https://vision.googleapis.com/v1/images:annotate", data=json.dumps(body).encode(), |
| headers={"Content-Type": "application/json", "Authorization": "Bearer " + TOK[0], "x-goog-user-project": os.environ["GOOGLE_CLOUD_PROJECT"]}) |
| d = json.loads(urllib.request.urlopen(req, timeout=300).read())["responses"][0] |
| if d.get("error"): raise RuntimeError(str(d["error"])[:200]) |
| fta = d.get("fullTextAnnotation") or {} |
| out = [] |
| for pg in fta.get("pages", []): |
| W, H = pg.get("width") or 1, pg.get("height") or 1 |
| for b in pg.get("blocks", []): |
| v = b.get("boundingBox", {}).get("vertices", []) |
| xs = [p.get("x", 0) for p in v] or [0]; ys = [p.get("y", 0) for p in v] or [0] |
| box = [round(min(xs) / W * 999), round(min(ys) / H * 999), round(max(xs) / W * 999), round(max(ys) / H * 999)] |
| box = [min(999, max(0, x)) for x in box] |
| out.append(f"<|det|>text [{box[0]}, {box[1]}, {box[2]}, {box[3]}]<|/det|>{block_text(b)}") |
| return "\n\n".join(out) |
| def work(r): |
| t0 = time.time(); err = None |
| for a in range(3): |
| try: |
| return {"id": r["id"], "text": call(r), "error": None, "seconds": round(time.time() - t0, 1)} |
| except Exception as e: |
| err = repr(e)[:200] |
| if hasattr(e, "read"): |
| try: err += " " + e.read().decode()[:300] |
| except Exception: pass |
| time.sleep(5 * (a + 1)) |
| return {"id": r["id"], "text": "", "error": err, "seconds": round(time.time() - t0, 1)} |
| print("gvision todo", len(todo), "done", len(done), flush=True) |
| with out.open("a") as f, ThreadPoolExecutor(threads) as ex: |
| for k, row in enumerate(ex.map(work, todo), 1): |
| f.write(json.dumps(row, ensure_ascii=False) + "\n"); f.flush() |
| if k % 50 == 0 or row["error"]: print(k, row["id"], row["error"] or "ok", row["seconds"], flush=True) |
| print("API_DONE gvision", flush=True) |
|
|
