Upload scripts/fill_html.py with huggingface_hub

scripts/fill_html.py

@@ -2,7 +2,18 @@
 """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.
+(TabRecSet) get HTML generated here.
+
+Token grammar handled:
+    <fcel>            new cell starts, text follows inline
+    <ecel>            empty cell
+    <lcel>            cell continues to the LEFT  -> colspan += 1
+    <ulcel>           cell continues ABOVE      -> rowspan += 1
+    <xcel>            continues both ways       -> colspan += 1, rowspan += 1
+    <nl>              end of row
+
+Rows shorter than the widest row are padded with empty cells, matching the
+square-grid convention PaddleOCR uses.
 
 Usage: python3 fill_html.py <in.parquet> <out.parquet> [--workers N]
 """
@@ -13,51 +24,95 @@ 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>"
+_TOK = re.compile(r"<(fcel|ecel|lcel|ulcel|xcel|nl)>")
+_WS = re.compile(r"\s+")
+
+_ESC = {"&": "&amp;", "<": "&lt;", ">": "&gt;"}
+
+
+def _esc(t):
+    return "".join(_ESC.get(c, c) for c in t)
+
+
+def parse_otsl(otsl):
+    """-> list of rows; each row is a list of (text, colspan, rowspan)."""
+    rows, cur = [], []
+    cell = None          # [text, colspan, rowspan] of the cell being filled
+
+    def flush():
+        nonlocal cell
+        if cell is not None:
+            cur.append((cell[0].strip(), cell[1], cell[2]))
+            cell = None
+
+    pos = 0
+    for m in _TOK.finditer(otsl or ""):
+        text = otsl[pos:m.start()]
+        pos = m.end()
+        tag = m.group(1)
+        if cell is not None:
+            cell[0] += text
+        if tag == "fcel":
+            flush()
+            cell = ["", 1, 1]
+        elif tag == "ecel":
+            flush()
+            cur.append(("", 1, 1))
+        elif tag == "lcel":
+            # continuation extends the *current* cell if one is open,
+            # otherwise the last one already committed to this row
+            if cell is not None:
+                cell[1] += 1
+            elif cur:
+                t, cs, rs = cur[-1]
+                cur[-1] = (t, cs + 1, rs)
+        elif tag == "ulcel":
+            if cell is not None:
+                cell[2] += 1
+            elif cur:
+                t, cs, rs = cur[-1]
+                cur[-1] = (t, cs, rs + 1)
+        elif tag == "xcel":
+            if cell is not None:
+                cell[1] += 1
+                cell[2] += 1
+            elif cur:
+                t, cs, rs = cur[-1]
+                cur[-1] = (t, cs + 1, rs + 1)
+        elif tag == "nl":
+            flush()
+            rows.append(cur)
+            cur = []
+    flush()
+    if cur:
+        rows.append(cur)
+    return rows
 
 
 def otsl_to_html(otsl):
-    """Rebuild a minimal <table> from an OTSL token string."""
-    if not otsl:
+    """Rebuild a <table> from an OTSL token string."""
+    rows = parse_otsl(otsl)
+    rows = [r for r in rows if r]
+    if not rows:
         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>"
+    width = max(sum(c[1] for c in r) for r in rows) or 1
+
+    body = []
+    for r in rows:
+        tds, used = [], 0
+        for text, cs, rs in r:
+            used += cs
+            attrs = ""
+            if cs > 1:
+                attrs += f' colspan="{cs}"'
+            if rs > 1:
+                attrs += f' rowspan="{rs}"'
+            tds.append(f"<td{attrs}>{_esc(text)}</td>")
+        while used < width:                     # pad short rows
+            tds.append("<td></td>")
+            used += 1
+        body.append("<tr>" + "".join(tds) + "</tr>")
+    return "<table>" + "".join(body) + "</table>"
 
 
 def work(chunk):
@@ -70,33 +125,25 @@ def main():
 
     pf = pq.ParquetFile(src)
     schema = pf.schema_arrow
-    out = pq.ParquetWriter(dst, schema, compression="zstd")
+    writer = 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]]
+            t = pf.read_row_group(rg)
+            htmls = t.column("html").to_pylist()
+            otsls = t.column("otsl").to_pylist()
+            todo = [i for i in range(len(otsls)) if not htmls[i] 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
+                for i, s in zip(todo, pool.map(work, [otsls[i] for i in todo],
+                                                chunksize=64)):
+                    htmls[i] = s
+                filled += len(todo)
             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()
+            t = t.set_column(i, schema.field("html"),
+                             pa.array(htmls, type=schema.field("html").type))
+            writer.write_table(t)
+            total += t.num_rows
+    writer.close()
     print(f"done: {total} rows, {filled} html generated -> {dst}")