Upload scripts/fill_html.py with huggingface_hub

scripts/fill_html.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Fill missing `html` by converting each row's `otsl` (the reverse direction).
+
+OTSL and HTML are interconvertible. Sources that ship OTSL but no HTML
+(TabRecSet) get HTML generated here with a worker pool.
+
+Usage: python3 fill_html.py <in.parquet> <out.parquet> [--workers N]
+"""
+import multiprocessing as mp
+import re
+import sys
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+# OTSL -> HTML cell kind. PaddleOCR's tokens:
+#   <fcel>  new cell
+#   <ecel>  empty/blank cell
+#   <lcel>  cell merged with the one to its left (colspan)
+#   <ulcel> cell merged with the one above (rowspan)
+#   <xcel>  merged both ways
+#   <nl>    end of row
+STRUCT = re.compile(r"<(fcel|ecel|lcel|ulcel|xcel|ucel|nl)>")
+TAG_RE = re.compile(r"<(/?)([a-zA-Z]+)[^>]*>")
+
+
+def _cell_html(tag, text):
+    if tag in ("lcel",):
+        return ""              # continuation of the previous cell
+    if tag == "ecel":
+        return "<td></td>"
+    if tag in ("ulcel", "ucel", "xcel"):
+        return "<td></td>"    # vertical continuation, rendered as a blank cell
+    return f"<td>{text}</td>"
+
+
+def otsl_to_html(otsl):
+    """Rebuild a minimal <table> from an OTSL token string."""
+    if not otsl:
+        return ""
+    # split into rows, then into (token, text) pairs
+    rows_html = []
+    for row in STRUCT.split(otsl):
+        if not row:
+            continue
+        parts = row.split(">")
+        cells, buf = [], ""
+        for p in parts:
+            m = re.fullmatch(r"\s*(fcel|ecel|lcel|ulcel|xcel|ucel)\s*", p)
+            if m:
+                cells.append((m.group(1), buf))
+                buf = ""
+            else:
+                buf += p
+        out = "".join(_cell_html(t, tx) for t, tx in cells)
+        if out:
+            rows_html.append(f"<tr>{out}</tr>")
+    if not rows_html:
+        return ""
+    return "<table>" + "".join(rows_html) + "</table>"
+
+
+def work(chunk):
+    return [otsl_to_html(o) for o in chunk]
+
+
+def main():
+    src, dst = sys.argv[1], sys.argv[2]
+    workers = int(sys.argv[sys.argv.index("--workers") + 1]) if "--workers" in sys.argv else 128
+
+    pf = pq.ParquetFile(src)
+    schema = pf.schema_arrow
+    out = pq.ParquetWriter(dst, schema, compression="zstd")
+    total = filled = 0
+
+    with mp.Pool(workers) as pool:
+        for rg in range(pf.num_row_groups):
+            tbl = pf.read_row_group(rg)
+            htmls = tbl.column("html").to_pylist()
+            otsls = tbl.column("otsl").to_pylist()
+            todo = [i for i, h in enumerate(htmls) if not h and otsls[i]]
+            if todo:
+                chunks = [otsls[i] for i in todo]
+                n = (len(chunks) + workers * 4 - 1) // (workers * 4)
+                pieces = [chunks[k:k + n] for k in range(0, len(chunks), n)]
+                done = 0
+                for piece, res in zip(pieces, pool.map(work, pieces)):
+                    for i, s in zip(todo[done:done + len(piece)], res):
+                        htmls[i] = s
+                    done += len(piece)
+                filled += done
+            i = schema.get_field_index("html")
+            tbl = tbl.set_column(i, schema.field("html"),
+                                 pa.array(htmls, type=schema.field("html").type))
+            out.write_table(tbl)
+            total += tbl.num_rows
+            print(f"  {total} rows, filled {filled}", flush=True)
+
+    out.close()
+    print(f"done: {total} rows, {filled} html generated -> {dst}")
+
+
+if __name__ == "__main__":
+    main()