Update app.py

app.py

@@ -21,9 +21,9 @@ 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; 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).
+    grid, then slide a solitary amount token past trailing blank logical slots
+    into the rightmost slot (colspan-aware). Rowspan rows are skipped for edits
+    but do not disable an entire table. Stabilization runs in multiple passes.
 
 Configure GLMOCR_API_KEY (environment variable). Optional: glmocr + gradio +
 pymupdf + pillow installed.
@@ -344,14 +344,15 @@ def _is_whole_cell_currency(text: str) -> bool:
     True iff the cell is nothing but a currency-looking amount (optional $, commas, 2 decimals).
     Excludes dates (slashes) and arbitrary prose — not keyed to column headers.
     """
-    if not text or "/" in text:
+    t = (text or "").strip().strip("* \t\u00a0")
+    if not t or "/" in t:
         return False
     return bool(
         re.fullmatch(
             r"-?(?:\$|€|£)?\s*\d{1,3}(?:,\d{3})*\.\d{2}\s*",
-            text,
+            t,
         )
-        or re.fullmatch(r"-?(?:\$|€|£)?\s*\d+\.\d{2}\s*", text)
+        or re.fullmatch(r"-?(?:\$|€|£)?\s*\d+\.\d{2}\s*", t)
     )
 
 
@@ -385,28 +386,31 @@ def _logical_plain_texts_from_entries(entries: List[Tuple[str, int]]) -> List[st
     return out
 
 
-def _shift_lone_amount_past_trailing_blanks(log: List[str]) -> List[str]:
+def _shift_rightmost_currency_with_blank_suffix(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).
+    Find the rightmost logical slot that is currency-only and has only blank
+    slots to the end; move that amount into the rightmost slot. Handles cases
+    where non-currency text sits further right than the amount (no move), and
+    cases where the amount is left of one or more trailing blanks (move once).
     """
     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)):
+    j = -1
+    for i in range(w - 1, -1, -1):
+        t = (log[i] or "").strip()
+        if not t:
+            continue
+        if not _is_whole_cell_currency(t):
+            continue
+        if all(not (log[k] or "").strip() for k in range(i + 1, w)):
+            j = i
+            break
+    if j < 0 or j == w - 1:
         return log
     new_log = list(log)
-    new_log[L] = ""
+    token = (new_log[j] or "").strip()
+    new_log[j] = ""
     new_log[w - 1] = token
     return new_log
 
@@ -430,29 +434,32 @@ def _materialize_cells_from_logical(
 
 
 def _apply_row_amount_tail_shift(cells: List[str], spans: List[int]) -> List[str]:
-    """Colspan-aware tail shift; returns possibly unchanged cell HTML list."""
+    """Colspan-aware tail shift; repeat until stable (handles chained blanks)."""
     if not cells or len(cells) != len(spans):
         return cells
-    entries = list(zip(cells, spans))
-    old_log = _logical_plain_texts_from_entries(entries)
-    if len(old_log) < 2:
-        return cells
-    new_log = _shift_lone_amount_past_trailing_blanks(old_log)
-    if new_log == old_log:
-        return cells
-    return _materialize_cells_from_logical(entries, new_log)
+    for _ in range(24):
+        entries = list(zip(cells, spans))
+        old_log = _logical_plain_texts_from_entries(entries)
+        if len(old_log) < 2:
+            break
+        new_log = _shift_rightmost_currency_with_blank_suffix(old_log)
+        if new_log == old_log:
+            break
+        cells = _materialize_cells_from_logical(entries, new_log)
+    return cells
 
 
 def _infer_modal_logical_width(tr_inners: List[str]) -> int:
     """
     Modal logical column count across rows (colspan sums). On frequency ties,
     prefer the larger width so a rare short row is padded to the majority grid.
-    Returns -1 if the table uses rowspan (skip) or has no measurable rows.
+    Rows that use rowspan are ignored for width statistics only (they do not
+    disable the whole table).
     """
     widths: List[int] = []
     for inner in tr_inners:
         if re.search(r"rowspan\s*=", inner, flags=re.IGNORECASE):
-            return -1
+            continue
         w = _logical_row_width(_cell_entries(inner))
         if w > 0:
             widths.append(w)
@@ -557,6 +564,17 @@ def normalize_html_table_row_widths(md: str) -> str:
     )
 
 
+def stabilize_table_markup(md: str, rounds: int = 4) -> str:
+    """Apply table row normalization repeatedly until stable or rounds exhausted."""
+    cur = md
+    for _ in range(max(1, rounds)):
+        nxt = normalize_html_table_row_widths(cur)
+        if nxt == cur:
+            break
+        cur = nxt
+    return cur
+
+
 def looks_like_markdown_table(block: str) -> bool:
     lines = [ln.rstrip() for ln in block.strip().splitlines() if ln.strip()]
     if len(lines) < 2:
@@ -626,7 +644,7 @@ def light_stabilize_markdown(page_md: str) -> str:
         else:
             out_blocks.append(b)
     merged = close_unclosed_html("\n\n".join(out_blocks))
-    return normalize_html_table_row_widths(merged)
+    return stabilize_table_markup(merged, rounds=4)
 
 
 def render_pdf_pages_to_images(pdf_path: str) -> Tuple[List[str], List[int]]:
@@ -764,6 +782,8 @@ def run_ocr(uploaded_file):
                 all_pages.append("\n\n".join(parts))
 
         merged = "\n\n---page-separator---\n\n".join(all_pages) if all_pages else "(No content)"
+        if merged and merged != "(No content)" and not merged.lstrip().startswith("Error:"):
+            merged = stabilize_table_markup(merged, rounds=4)
         return merged
 
     except Exception as e: