| """Measure what is inside each downloaded phase 1 source.
|
|
|
| usage: python data/profile.py [--root DIR] [--only NAME ...]
|
|
|
| Writes data/reports/phase1/profile/<name>.json: counts (pages, lines, words,
|
| characters), the character set and its Unicode scripts, line geometry, layout
|
| labels, PDF text-layer coverage, font coverage, whatever applies to that
|
| source. report.py turns these into the comparison report.
|
|
|
| Big sources are sampled where reading everything adds nothing (PDF text is
|
| read from up to SAMPLE_PDFS documents per source; every annotation file is
|
| read whole). Each profile records what it sampled.
|
| """
|
| import argparse
|
| import collections
|
| import gzip
|
| import io
|
| import json
|
| import math
|
| import re
|
| import sys
|
| import tarfile
|
| import time
|
| import zipfile
|
| from pathlib import Path
|
|
|
| from fontTools import unicodedata as fu
|
|
|
| from fetch import DEFAULT_ROOT
|
| from sources import BY_NAME, SOURCES
|
|
|
| HERE = Path(__file__).resolve().parent
|
| OUT = HERE / "reports" / "phase1" / "profile"
|
| SAMPLE_PDFS = 1500
|
| TEXT_SAMPLE_CHARS = 60_000_000
|
|
|
|
|
|
|
| LATIN_TEST = {
|
| "latin1": "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ",
|
| "latin_ext_a": "ĀāĂ㥹ĆćČčĎďĐđĒēĖėĘęĚěĞğĪīĮįİıĽľŁłŃńŇňŐőŒœŘřŚśŞşŠšŢţŤťŮůŰűŸŹźŻżŽž",
|
| "vietnamese": "ẠạẢảẤấẦầẨẩẪẫẬậẮắẰằẲẳẴẵẶặẸẹẺẻẼẽẾếỀềỂểỄễỆệỈỉỊịỌọỎỏỐốỒồỔổỖỗỘộỚớỜờỞởỠỡỢợỤụỦủỨứỪừỬửỮữỰựỲỳỴỵỶỷỸỹƠơƯư",
|
| "yoruba": "ẸẹỌọṢṣ",
|
| "eszett": "ẞß",
|
| }
|
|
|
|
|
| def log(name, msg):
|
| print(f"[{time.strftime('%H:%M:%S')}] {name}: {msg}", flush=True)
|
|
|
|
|
| def pct(values, qs=(5, 50, 95)):
|
| if not values:
|
| return {}
|
| v = sorted(values)
|
| return {f"p{q}": round(v[min(len(v) - 1, int(q / 100 * len(v)))], 2) for q in qs}
|
|
|
|
|
| class Chars:
|
| """Character statistics over a stream of strings."""
|
|
|
| def __init__(self):
|
| self.counts = collections.Counter()
|
| self.strings = 0
|
| self.lengths = []
|
|
|
| def add(self, s):
|
| if not s:
|
| return
|
| self.counts.update(s)
|
| self.strings += 1
|
| if len(self.lengths) < 200_000:
|
| self.lengths.append(len(s))
|
|
|
| def summary(self, top_scripts=8):
|
| total = sum(self.counts.values())
|
| if not total:
|
| return {"characters": 0}
|
| scripts = collections.Counter()
|
| for ch, n in self.counts.items():
|
| if not ch.isspace():
|
| scripts[fu.script(ch)] += n
|
| letters = sum(n for s, n in scripts.items() if s not in ("Zyyy", "Zinh", "Zzzz"))
|
| ranked = [n for _, n in self.counts.most_common()]
|
| cum, k999, k9999 = 0, None, None
|
| for i, n in enumerate(ranked, 1):
|
| cum += n
|
| if k999 is None and cum >= 0.999 * total:
|
| k999 = i
|
| if k9999 is None and cum >= 0.9999 * total:
|
| k9999 = i
|
| break
|
| return {
|
| "strings": self.strings,
|
| "characters": total,
|
| "unique_characters": len(self.counts),
|
| "chars_for_99.9pct": k999,
|
| "chars_for_99.99pct": k9999,
|
| "scripts": {s: round(n / max(letters, 1), 4) for s, n in scripts.most_common(top_scripts)
|
| if s not in ("Zyyy", "Zinh", "Zzzz")},
|
| "digits_share": round(sum(n for c, n in self.counts.items() if c.isdigit()) / total, 4),
|
| "length": pct(self.lengths),
|
| "latin_test_coverage": {k: round(sum(1 for c in v if c in self.counts) / len(v), 3)
|
| for k, v in LATIN_TEST.items()},
|
| "rarest_seen": "".join(c for c, _ in self.counts.most_common()[-40:] if not c.isspace()),
|
| }
|
|
|
|
|
|
|
|
|
| def cmap_of(path):
|
| from fontTools.ttLib import TTFont
|
| try:
|
| f = TTFont(path, fontNumber=0, lazy=True)
|
| return set(f.getBestCmap() or {})
|
| except Exception:
|
| return None
|
|
|
|
|
| def font_coverage(cmaps):
|
| out = {}
|
| for k, chars in LATIN_TEST.items():
|
| cps = {ord(c) for c in chars}
|
| full = sum(1 for c in cmaps if cps <= c)
|
| out[k] = round(full / max(len(cmaps), 1), 3)
|
| return out
|
|
|
|
|
| def profile_fonts_google(src, d):
|
| fams = []
|
| for meta in d.glob("*/*/METADATA.pb"):
|
| t = meta.read_text(encoding="utf-8", errors="replace")
|
| cat = re.search(r'category:\s*"([A-Z_]+)"', t)
|
| subsets = re.findall(r'subsets:\s*"([\w-]+)"', t)
|
| fonts = sorted(meta.parent.glob("*.ttf"))
|
| regular = next((f for f in fonts if "Regular" in f.name), fonts[0] if fonts else None)
|
| fams.append(dict(license_dir=meta.parent.parent.name, category=cat.group(1) if cat else "?",
|
| subsets=subsets, files=len(fonts), regular=regular))
|
| log(src["name"], f"{len(fams)} families; reading cmaps")
|
| latin = [f for f in fams if "latin" in f["subsets"] and f["regular"]]
|
| cm = {}
|
| for f in latin:
|
| c = cmap_of(f["regular"])
|
| if c is not None:
|
| cm[f["regular"]] = c
|
| by_cat = collections.defaultdict(list)
|
| for f in latin:
|
| if f["regular"] in cm:
|
| by_cat[f["category"]].append(cm[f["regular"]])
|
| subsets = collections.Counter(s for f in fams for s in f["subsets"])
|
| return {
|
| "families": len(fams),
|
| "font_files": sum(f["files"] for f in fams),
|
| "by_license_dir": dict(collections.Counter(f["license_dir"] for f in fams)),
|
| "by_category": dict(collections.Counter(f["category"] for f in fams)),
|
| "subsets_top": dict(subsets.most_common(30)),
|
| "latin_families_checked": len(cm),
|
| "latin_full_coverage_share": font_coverage(list(cm.values())),
|
| "latin_full_coverage_by_category": {k: font_coverage(v) for k, v in by_cat.items()},
|
| "N_tilde_missing_in_display": sum(1 for c in by_cat.get("DISPLAY", []) if 0xD1 not in c),
|
| }
|
|
|
|
|
| def profile_fonts_noto(src, d):
|
| files = [p for p in d.rglob("*.ttf") if "full" in p.parts or "hinted" in p.parts or "unhinted" in p.parts]
|
| fams = collections.defaultdict(list)
|
| for p in files:
|
| fams[p.name.split("-")[0]].append(p)
|
| scripts = collections.Counter()
|
| for fam, ps in fams.items():
|
| regular = next((p for p in ps if "Regular" in p.name), ps[0])
|
| c = cmap_of(regular) or set()
|
| sc = collections.Counter(fu.script(chr(u)) for u in c if 0x20 < u < 0x110000)
|
| for s, _ in sc.most_common(1):
|
| scripts[s] += 1
|
| return {"families": len(fams), "font_files": len(files),
|
| "main_script_of_family": dict(scripts.most_common(80)), "distinct_main_scripts": len(scripts)}
|
|
|
|
|
| def profile_langdata(src, d):
|
| langs = {}
|
| for p in d.glob("*/*.training_text"):
|
| langs.setdefault(p.parent.name, 0)
|
| langs[p.parent.name] += p.stat().st_size
|
| chars = Chars()
|
| for lang in ("eng", "deu", "fra", "spa", "vie", "pol", "ces", "tur"):
|
| p = d / lang / f"{lang}.training_text"
|
| if p.exists():
|
| chars.add(p.read_text(encoding="utf-8", errors="replace")[:5_000_000])
|
| fonts = sum(1 for _ in d.glob("*/okfonts.txt"))
|
| return {"languages_with_training_text": len(langs), "training_text_bytes": sum(langs.values()),
|
| "largest": dict(sorted(langs.items(), key=lambda x: -x[1])[:10]), "font_lists": fonts,
|
| "latin_sample_chars": chars.summary()}
|
|
|
|
|
|
|
|
|
| def profile_parquet_text(src, d):
|
| import pyarrow.parquet as pq
|
| out = {}
|
| for p in sorted(d.rglob("*.parquet")):
|
| pf = pq.ParquetFile(p)
|
| chars, n, taken = Chars(), pf.metadata.num_rows, 0
|
| total_chars = 0
|
| for batch in pf.iter_batches(columns=["text"], batch_size=2000):
|
| for t in batch.column(0).to_pylist():
|
| t = t or ""
|
| total_chars += len(t)
|
| if taken < TEXT_SAMPLE_CHARS:
|
| chars.add(t)
|
| taken += len(t)
|
| key = p.relative_to(d).as_posix()
|
| out[key] = {"documents": n, "characters": total_chars, "sampled_characters": taken,
|
| "chars": chars.summary()}
|
| log(src["name"], f"{key}: {n} docs, {total_chars / 1e6:.0f} M chars")
|
| return {"files": out, "documents": sum(v["documents"] for v in out.values()),
|
| "characters": sum(v["characters"] for v in out.values())}
|
|
|
|
|
|
|
|
|
| def quad_geometry(q):
|
| (x0, y0), (x1, y1), (x2, y2), (x3, y3) = q
|
| width = math.hypot(x1 - x0, y1 - y0)
|
| height = math.hypot(x3 - x0, y3 - y0)
|
| angle = math.degrees(math.atan2(y1 - y0, x1 - x0))
|
| return width, height, angle
|
|
|
|
|
| def profile_nvidia(src, d):
|
| import h5py
|
| per_lang = {}
|
| for p in sorted(d.rglob("*.h5")):
|
| lang = p.relative_to(d).parts[0]
|
| s = per_lang.setdefault(lang, dict(files=0, samples=0, lines=[], words=[], paras=[], heights=[],
|
| angles=[], widths=[], dims=[], chars=Chars(), with_order=0))
|
| s["files"] += 1
|
| with h5py.File(p, "r") as f:
|
| ann = f["annotations"]
|
| dims = f["dimensions"][:]
|
| n = len(ann)
|
| s["samples"] += n
|
| for i in range(n):
|
| a = json.loads(ann[i])
|
| lines = a.get("line_bboxes", [])
|
| s["lines"].append(len(lines))
|
| s["words"].append(len(a.get("word_bboxes", [])))
|
| s["paras"].append(len(a.get("para_bboxes", [])))
|
| s["with_order"] += bool(a.get("relation_graph"))
|
| for ln in lines[:40]:
|
| s["chars"].add(ln.get("text", ""))
|
| if ln.get("quad"):
|
| w, h, ang = quad_geometry(ln["quad"])
|
| if len(s["heights"]) < 400_000:
|
| s["heights"].append(h)
|
| s["angles"].append(ang)
|
| s["widths"].append(w)
|
| if len(s["dims"]) < 50_000:
|
| s["dims"].append(tuple(int(x) for x in dims[i][:2]))
|
| log(src["name"], f"{p.name}: {n} samples")
|
| out = {}
|
| for lang, s in per_lang.items():
|
| hs = [h for h, _ in s["dims"]]
|
| ws = [w for _, w in s["dims"]]
|
| rot = sum(1 for a in s["angles"] if abs(a) > 2)
|
| out[lang] = {
|
| "files": s["files"], "samples": s["samples"],
|
| "lines_per_page": pct(s["lines"]), "words_per_page": pct(s["words"]),
|
| "paragraphs_per_page": pct(s["paras"]), "lines_total": sum(s["lines"]),
|
| "line_height_px": pct(s["heights"]), "line_width_px": pct(s["widths"]),
|
| "lines_tilted_over_2deg_share": round(rot / max(len(s["angles"]), 1), 4),
|
| "page_height_px": pct(hs), "page_width_px": pct(ws),
|
| "with_reading_order_share": round(s["with_order"] / max(s["samples"], 1), 4),
|
| "chars": s["chars"].summary(),
|
| }
|
| return out
|
|
|
|
|
|
|
|
|
|
|
| DOCLAYNET_LABELS = {1: "Caption", 2: "Footnote", 3: "Formula", 4: "List-item", 5: "Page-footer", 6: "Page-header",
|
| 7: "Picture", 8: "Section-header", 9: "Table", 10: "Text", 11: "Title"}
|
|
|
|
|
| def profile_doclaynet(src, d):
|
| import pyarrow.parquet as pq
|
| files = sorted(d.rglob("*.parquet"))
|
| schema = pq.ParquetFile(files[0]).schema_arrow
|
| cols = [n for n in schema.names if n not in ("image", "images", "pdf")]
|
| splits, cats, doc_cats, cells, texts = collections.Counter(), collections.Counter(), collections.Counter(), 0, Chars()
|
| sizes = []
|
| for p in files:
|
| split = p.name.split("-")[0]
|
| pf = pq.ParquetFile(p)
|
| splits[split] += pf.metadata.num_rows
|
| for batch in pf.iter_batches(columns=cols, batch_size=500):
|
| for row in batch.to_pylist():
|
| cats.update(DOCLAYNET_LABELS.get(x, str(x)) for x in row.get("category_id") or [])
|
| meta = row.get("metadata") or {}
|
| if isinstance(meta, str):
|
| try:
|
| meta = json.loads(meta)
|
| except ValueError:
|
| meta = {}
|
| if isinstance(meta, dict):
|
| if meta.get("doc_category"):
|
| doc_cats[meta["doc_category"]] += 1
|
| if meta.get("original_width") and len(sizes) < 50_000:
|
| sizes.append((meta["original_width"], meta["original_height"]))
|
|
|
| for box in row.get("pdf_cells") or []:
|
| cells += len(box)
|
| for c in box:
|
| if isinstance(c.get("text"), str):
|
| texts.add(c["text"])
|
| log(src["name"], f"{p.name} done")
|
| return {"pages_by_split": dict(splits), "pages": sum(splits.values()), "columns": schema.names,
|
| "label_instances": dict(cats.most_common(30)), "doc_categories": dict(doc_cats),
|
| "text_cells": cells, "cell_chars": texts.summary(),
|
| "page_width_pt": pct([w for w, _ in sizes]), "page_height_pt": pct([h for _, h in sizes])}
|
|
|
|
|
|
|
|
|
| def profile_hiertext(src, d):
|
| out = {}
|
| for split in ("train", "validation", "test"):
|
| p = d / f"{split}.jsonl.gz"
|
| if not p.exists():
|
| continue
|
| data = json.loads(gzip.open(p, "rt", encoding="utf-8").read())
|
| anns = data.get("annotations", [])
|
| n = dict(images=len(anns), paragraphs=0, lines=0, words=0, illegible=0, handwritten=0, vertical=0)
|
| chars, heights = Chars(), []
|
| for a in anns:
|
| for para in a.get("paragraphs", []):
|
| n["paragraphs"] += 1
|
| for ln in para.get("lines", []):
|
| n["lines"] += 1
|
| chars.add(ln.get("text", ""))
|
| for w in ln.get("words", []):
|
| n["words"] += 1
|
| n["illegible"] += not w.get("legible", True)
|
| n["handwritten"] += bool(w.get("handwritten"))
|
| n["vertical"] += bool(w.get("vertical"))
|
| v = w.get("vertices")
|
| if v and len(heights) < 300_000:
|
| ys = [pt[1] for pt in v]
|
| heights.append(max(ys) - min(ys))
|
| n.update(word_height_px=pct(heights), chars=chars.summary())
|
| out[split] = n
|
| for tgz in sorted(d.glob("*.tgz")):
|
| with tarfile.open(tgz, "r:gz") as t:
|
| out.setdefault("image_archives", {})[tgz.name] = sum(1 for m in t if m.isfile())
|
| return out
|
|
|
|
|
| def profile_textocr(src, d):
|
| out = {}
|
| for split in ("train", "val"):
|
| p = d / f"TextOCR_0.1_{split}.json"
|
| if not p.exists():
|
| continue
|
| data = json.loads(p.read_text(encoding="utf-8"))
|
| anns = data["anns"].values()
|
| chars, heights, illegible = Chars(), [], 0
|
| for a in anns:
|
| s = a.get("utf8_string", "")
|
| if s == ".":
|
| illegible += 1
|
| continue
|
| chars.add(s)
|
| if a.get("bbox") and len(heights) < 300_000:
|
| heights.append(a["bbox"][3])
|
| out[split] = dict(images=len(data["imgs"]), words=len(data["anns"]), illegible=illegible,
|
| word_height_px=pct(heights), chars=chars.summary())
|
| z = d / "train_val_images.zip"
|
| if z.exists():
|
| with zipfile.ZipFile(z) as zf:
|
| out["image_files"] = sum(1 for i in zf.infolist() if not i.is_dir())
|
| return out
|
|
|
|
|
|
|
|
|
| def profile_gt4histocr(src, d):
|
| out = {}
|
| for outer in d.glob("*.tar"):
|
| with tarfile.open(outer) as t:
|
| for m in t:
|
| if not m.isfile():
|
| continue
|
| f = t.extractfile(m)
|
| if m.name.endswith((".tar.bz2", ".tar.gz", ".tar", ".tbz2")):
|
| corpus = Path(m.name).name.split(".")[0]
|
| stats = dict(lines=0, images=0, chars=Chars())
|
| with tarfile.open(fileobj=f, mode="r|*") as inner:
|
| for im in inner:
|
| if im.name.endswith(".gt.txt"):
|
| stats["lines"] += 1
|
| stats["chars"].add(inner.extractfile(im).read().decode("utf-8", "replace").strip())
|
| elif im.name.endswith((".png", ".tif", ".jpg", ".bin.png", ".nrm.png")):
|
| stats["images"] += 1
|
| out[corpus] = dict(lines=stats["lines"], images=stats["images"], chars=stats["chars"].summary())
|
| log(src["name"], f"{corpus}: {stats['lines']} lines")
|
| return {"corpora": out, "lines": sum(v["lines"] for v in out.values())}
|
|
|
|
|
|
|
|
|
| def profile_hf_parquet(src, d):
|
| import pyarrow.parquet as pq
|
| out = {}
|
| for p in sorted(d.rglob("*.parquet")):
|
| pf = pq.ParquetFile(p)
|
| schema = pf.schema_arrow
|
| textcols = [n for n in schema.names if n in ("text", "transcription", "ground_truth", "label", "words", "tokens")]
|
| chars = Chars()
|
| if textcols:
|
| for batch in pf.iter_batches(columns=textcols, batch_size=500):
|
| for col in batch.columns:
|
| for v in col.to_pylist():
|
| if isinstance(v, str):
|
| chars.add(v)
|
| elif isinstance(v, list):
|
| for x in v:
|
| if isinstance(x, str):
|
| chars.add(x)
|
| out[p.relative_to(d).as_posix()] = dict(rows=pf.metadata.num_rows, columns=schema.names,
|
| chars=chars.summary())
|
| return {"files": out, "rows": sum(v["rows"] for v in out.values())}
|
|
|
|
|
|
|
|
|
| def pdf_stats(data, pages_to_read=3):
|
| import pypdfium2 as pdfium
|
| doc = pdfium.PdfDocument(data)
|
| n = len(doc)
|
| chars, sizes = [], []
|
| text = ""
|
| for i in range(min(n, pages_to_read)):
|
| page = doc[i]
|
| w, h = page.get_size()
|
| sizes.append((round(w), round(h)))
|
| t = page.get_textpage().get_text_range()
|
| chars.append(len(t.strip()))
|
| text += t
|
| return n, chars, sizes, text
|
|
|
|
|
| def page_format(w, h):
|
| w, h = sorted((w, h))
|
| if abs(w - 612) < 8 and abs(h - 792) < 8:
|
| return "Letter"
|
| if abs(w - 595) < 8 and abs(h - 842) < 8:
|
| return "A4"
|
| return "other"
|
|
|
|
|
| class PdfSet:
|
| def __init__(self):
|
| self.docs = self.failed = 0
|
| self.pages, self.chars_per_page, self.formats = [], [], collections.Counter()
|
| self.text_pages = self.empty_pages = 0
|
| self.chars = Chars()
|
|
|
| def add(self, data):
|
| try:
|
| n, chars, sizes, text = pdf_stats(data)
|
| except Exception:
|
| self.failed += 1
|
| return
|
| self.docs += 1
|
| self.pages.append(n)
|
| for c in chars:
|
| self.chars_per_page.append(c)
|
| if c >= 50:
|
| self.text_pages += 1
|
| else:
|
| self.empty_pages += 1
|
| for w, h in sizes:
|
| self.formats[page_format(w, h)] += 1
|
| self.chars.add(text[:20000])
|
|
|
| def summary(self):
|
| read = self.text_pages + self.empty_pages
|
| return {"documents_read": self.docs, "unreadable": self.failed, "pages_per_doc": pct(self.pages),
|
| "pages_total_in_read_docs": sum(self.pages), "chars_per_page": pct(self.chars_per_page),
|
| "pages_with_text_layer_share": round(self.text_pages / max(read, 1), 4),
|
| "page_formats": dict(self.formats), "chars": self.chars.summary()}
|
|
|
|
|
| def profile_pdf_dir(src, d):
|
| s = PdfSet()
|
| for p in sorted((d / "pdf").glob("*.pdf"))[:SAMPLE_PDFS]:
|
| s.add(p.read_bytes())
|
| lic = collections.Counter()
|
| m = HERE / "manifests" / "phase1" / f"{src['name']}.json"
|
| if m.exists():
|
| for f in json.loads(m.read_text(encoding="utf-8"))["files"]:
|
| lic[f.get("license")] += 1
|
| return {"pdfs": len(list((d / "pdf").glob("*.pdf"))), "licenses": dict(lic), **s.summary()}
|
|
|
|
|
| def profile_govdocs(src, d):
|
| s, seen, exts = PdfSet(), 0, collections.Counter()
|
| for part in sorted(d.rglob("*.tar.a?")):
|
| try:
|
| with tarfile.open(part, "r|") as t:
|
| for m in t:
|
| if not m.isfile():
|
| continue
|
| seen += 1
|
| exts[Path(m.name).suffix.lower()] += 1
|
| if s.docs + s.failed < SAMPLE_PDFS and m.name.lower().endswith(".pdf"):
|
| s.add(t.extractfile(m).read())
|
| except (tarfile.ReadError, EOFError):
|
| pass
|
| return {"files_in_piece": seen, "extensions": dict(exts.most_common(8)), **s.summary()}
|
|
|
|
|
| def profile_pdfa(src, d):
|
| s, docs, pages, lines, words = PdfSet(), 0, [], [], []
|
| chars = Chars()
|
| for shard in sorted(d.rglob("*.tar")):
|
| with tarfile.open(shard) as t:
|
| for m in t:
|
| if not m.isfile():
|
| continue
|
| if m.name.endswith(".json"):
|
| docs += 1
|
| j = json.load(t.extractfile(m))
|
| pg = j.get("pages", [])
|
| pages.append(len(pg))
|
| for p in pg[:5]:
|
| ln = (p.get("lines") or {}).get("text") or []
|
| wd = (p.get("words") or {}).get("text") or []
|
| lines.append(len(ln))
|
| words.append(len(wd))
|
| for x in ln[:60]:
|
| chars.add(x)
|
| elif m.name.endswith(".pdf") and s.docs + s.failed < SAMPLE_PDFS:
|
| s.add(t.extractfile(m).read())
|
| log(src["name"], f"{shard.name}: {docs} documents so far")
|
| return {"documents": docs, "pages_per_doc": pct(pages), "pages_total": sum(pages),
|
| "lines_per_page": pct(lines), "words_per_page": pct(words), "label_chars": chars.summary(),
|
| "pdf_sample": s.summary()}
|
|
|
|
|
|
|
|
|
| def profile_files(src, d):
|
| exts = collections.Counter()
|
| size = 0
|
| for p in d.rglob("*"):
|
| if p.is_file() and ".cache" not in p.parts:
|
| exts[p.suffix.lower() or "-"] += 1
|
| size += p.stat().st_size
|
| out = {"files_by_type": dict(exts.most_common(10)), "bytes": size}
|
| if src["name"] in ("iam-line", "funsd"):
|
| out.update(profile_hf_parquet(src, d))
|
| return out
|
|
|
|
|
| PROFILERS = {
|
| "fonts-google": profile_fonts_google, "fonts-noto": profile_fonts_noto, "langdata-lstm": profile_langdata,
|
| "wikipedia": profile_parquet_text, "fineweb-2": profile_parquet_text, "finepdfs": profile_parquet_text,
|
| "nvidia-ocr-synthetic": profile_nvidia, "doclaynet": profile_doclaynet, "hiertext": profile_hiertext,
|
| "textocr": profile_textocr, "gt4histocr": profile_gt4histocr, "gnhk": profile_hf_parquet,
|
| "govdocs1": profile_govdocs, "pdfa-eng": profile_pdfa, "pmc-oa": profile_pdf_dir, "arxiv": profile_pdf_dir,
|
| "omni-parse-bench": profile_files, "omnidocbench": profile_files, "olmocr-bench": profile_files,
|
| "iam-line": profile_files, "funsd": profile_files,
|
| }
|
|
|
|
|
| def main():
|
| ap = argparse.ArgumentParser()
|
| ap.add_argument("--root", type=Path, default=DEFAULT_ROOT)
|
| ap.add_argument("--only", nargs="*")
|
| a = ap.parse_args()
|
| for stream in (sys.stdout, sys.stderr):
|
| stream.reconfigure(encoding="utf-8", errors="replace")
|
| OUT.mkdir(parents=True, exist_ok=True)
|
| for src in [BY_NAME[n] for n in a.only] if a.only else SOURCES:
|
| d = a.root / src["name"]
|
| if not d.exists():
|
| log(src["name"], "not downloaded; skipped")
|
| continue
|
| t0 = time.time()
|
| try:
|
| prof = PROFILERS[src["name"]](src, d)
|
| err = None
|
| except Exception as e:
|
| prof, err = {}, f"{type(e).__name__}: {e}"
|
| (OUT / f"{src['name']}.json").write_text(json.dumps(
|
| {"name": src["name"], "seconds": round(time.time() - t0), "error": err, "profile": prof},
|
| indent=1, ensure_ascii=False, default=str), encoding="utf-8")
|
| log(src["name"], f"profiled in {round(time.time() - t0)} s" + (f"; ERROR {err}" if err else ""))
|
|
|
|
|
| if __name__ == "__main__":
|
| sys.exit(main())
|
|
|
