Update app.py

app.py

@@ -20,8 +20,10 @@ Explicitly omitted vs the heavy Space build:
 
 Included (data-driven, no institution names):
   - HTML tables: modal logical width from rowspan-free rows (colspan-aware);
-    pad short rows; trim trailing empty cells; if last cell is empty and the
-    previous cell is only a currency token, move that token to the last column.
+    pad short rows; trim trailing empty cells; expand each row to a logical
+    grid, then if the rightmost non-empty slot is a solitary amount and only
+    blanks follow to the edge, slide that amount into the rightmost slot (works
+    with merged cells, not only uniform single-span rows).
 
 Configure GLMOCR_API_KEY (environment variable). Optional: glmocr + gradio +
 pymupdf + pillow installed.
@@ -76,7 +78,7 @@ if not GLMOCR_API_KEY:
 
 # Rasterization: higher scale = more pixels per PDF point (helps small type,
 # boxed headers, and narrow columns). Same constant for all uploads.
-RENDER_SCALE = 3.05
+RENDER_SCALE = 3.12
 
 # White margin as a fraction of page width/height after render. Extra right
 # margin helps right-aligned currency columns that hug the page edge.
@@ -87,12 +89,12 @@ PAD_BOTTOM_FRAC = 0.018
 
 ENABLE_CONTRAST = True
 # Slight contrast lift only; same factor for every file.
-CONTRAST_FACTOR = 1.16
+CONTRAST_FACTOR = 1.18
 
 # Subtle edge enhancement after contrast (helps hairlines and small digits).
 ENABLE_UNSHARP = True
 UNSHARP_RADIUS = 0.78
-UNSHARP_PERCENT = 72
+UNSHARP_PERCENT = 76
 UNSHARP_THRESHOLD = 1
 
 DEFAULT_ZONE_FRAC = 0.12
@@ -353,18 +355,92 @@ def _is_whole_cell_currency(text: str) -> bool:
     )
 
 
-def _realign_money_if_last_cell_empty(cells: List[str]) -> List[str]:
+def _replace_cell_plain_body(full_cell: str, new_body_plain: str) -> str:
+    """Rebuild one td/th preserving opening tag attributes; body is plain text (escaped)."""
+    m = _CELL.fullmatch(full_cell.strip())
+    if not m:
+        return full_cell
+    tag, attrs = m.group(1), m.group(2)
+    return f"<{tag}{attrs}>{html.escape(new_body_plain)}</{tag}>"
+
+
+def _logical_plain_texts_from_entries(entries: List[Tuple[str, int]]) -> List[str]:
     """
-    … | X | empty -> … | empty | X when X is currency-only (fixes amount parked
-    one column left of an empty trailing cell, including after width padding).
+    Flatten one table row to one string per logical column: merged spans place
+    full visible text on the first slot only, remainder empty strings.
     """
-    if len(cells) < 2:
+    w = sum(s for _, s in entries)
+    if w < 1:
+        return []
+    out = [""] * w
+    pos = 0
+    for full, span in entries:
+        span = max(1, span)
+        t = _cell_plain_text(full)
+        out[pos] = t
+        for k in range(1, span):
+            if pos + k < w:
+                out[pos + k] = ""
+        pos += span
+    return out
+
+
+def _shift_lone_amount_past_trailing_blanks(log: List[str]) -> List[str]:
+    """
+    If the rightmost non-blank slot is only a currency token and every slot to
+    its right is blank, move that token into the rightmost slot (any column count).
+    """
+    w = len(log)
+    if w < 2:
+        return log
+    L = w - 1
+    while L >= 0 and not (log[L] or "").strip():
+        L -= 1
+    if L < 0:
+        return log
+    token = (log[L] or "").strip()
+    if not _is_whole_cell_currency(token):
+        return log
+    if L == w - 1:
+        return log
+    if any((log[i] or "").strip() for i in range(L + 1, w)):
+        return log
+    new_log = list(log)
+    new_log[L] = ""
+    new_log[w - 1] = token
+    return new_log
+
+
+def _materialize_cells_from_logical(
+    entries: List[Tuple[str, int]], new_log: List[str]
+) -> List[str]:
+    """Rebuild physical td/th strings from a logical text row of length sum(span)."""
+    w = sum(s for _, s in entries)
+    if len(new_log) != w:
+        return [e[0] for e in entries]
+    pos = 0
+    rebuilt: List[str] = []
+    for full, span in entries:
+        span = max(1, span)
+        chunk = [(new_log[pos + k] or "").strip() for k in range(span)]
+        pos += span
+        body = " ".join(x for x in chunk if x).strip()
+        rebuilt.append(_replace_cell_plain_body(full, body))
+    return rebuilt
+
+
+def _apply_row_amount_tail_shift(cells: List[str], spans: List[int]) -> List[str]:
+    """Colspan-aware tail shift; returns possibly unchanged cell HTML list."""
+    if not cells or len(cells) != len(spans):
         return cells
-    if not _cell_text_empty(cells[-1]):
+    entries = list(zip(cells, spans))
+    old_log = _logical_plain_texts_from_entries(entries)
+    if len(old_log) < 2:
         return cells
-    if not _is_whole_cell_currency(_cell_plain_text(cells[-2])):
+    new_log = _shift_lone_amount_past_trailing_blanks(old_log)
+    if new_log == old_log:
         return cells
-    return cells[:-2] + ["<td></td>", cells[-2]]
+    return _materialize_cells_from_logical(entries, new_log)
 
 
 def _infer_modal_logical_width(tr_inners: List[str]) -> int:
@@ -405,8 +481,8 @@ def _normalize_one_tr_inner(tr_inner: str, target: int) -> str:
         w -= spans[-1]
         cells.pop()
         spans.pop()
-    if cells and all(s == 1 for s in spans):
-        cells = _realign_money_if_last_cell_empty(cells)
+    if cells:
+        cells = _apply_row_amount_tail_shift(cells, spans)
     return "".join(cells)
 
 
@@ -417,10 +493,9 @@ def normalize_html_table_row_widths(md: str) -> str:
     empty single-colspan cells from rows that are too wide.
 
     No column names or fixed N: width comes from per-table row statistics.
-    If the last cell is empty and the previous cell is only a currency token,
-    that amount is moved into the last column (whole-cell shape, not headers).
-    Tables with rowspan are skipped. Same-width wrong text that is not
-    currency-shaped is not altered.
+    Solitary amount tokens parked before a run of blank logical slots are slid
+    into the rightmost slot so OCR tables stay rectangular for downstream use.
+    Tables with rowspan are skipped. Non-currency text is not altered.
     """
     if not md or "<table" not in md.lower():
         return md