Update app.py

app.py

@@ -72,18 +72,21 @@ logging.basicConfig(level=logging.INFO)
 # Settings — tuned for dense financial PDFs; applies to every document
 # ---------------------------------------------------------------------------
 
+# Never commit secrets: Space / local runs use ZHIPU_API_KEY or GLMOCR_API_KEY.
 GLMOCR_API_KEY = "cee1d52dd91a4ab591b3f6e105f8ad89.LgbQTECuzX0zrito"
 if not GLMOCR_API_KEY:
-    log.warning("GLMOCR_API_KEY is not set; GlmOcr() will fail until you export it.")
+    log.warning(
+        "No ZHIPU_API_KEY or GLMOCR_API_KEY in environment; GlmOcr() will fail until you set one."
+    )
 
 # Rasterization: higher scale = more pixels per PDF point (helps small type,
 # boxed headers, and narrow columns). Same constant for all uploads.
-RENDER_SCALE = 3.12
+RENDER_SCALE = 3.35
 
 # White margin as a fraction of page width/height after render. Extra right
 # margin helps right-aligned currency columns that hug the page edge.
 PAD_LEFT_FRAC = 0.035
-PAD_RIGHT_FRAC = 0.11
+PAD_RIGHT_FRAC = 0.125
 PAD_TOP_FRAC = 0.018
 PAD_BOTTOM_FRAC = 0.018
 
@@ -144,7 +147,10 @@ def get_parser():
     if _parser is None:
         from glmocr import GlmOcr
 
-        _parser = GlmOcr(api_key=GLMOCR_API_KEY, mode="maas")
+        kw = {"mode": "maas"}
+        if GLMOCR_API_KEY:
+            kw["api_key"] = GLMOCR_API_KEY
+        _parser = GlmOcr(**kw)
     return _parser
 
 
@@ -575,6 +581,74 @@ def stabilize_table_markup(md: str, rounds: int = 4) -> str:
     return cur
 
 
+_THEAD_BLOCK = re.compile(r"<thead\b[^>]*>.*?</thead>", re.IGNORECASE | re.DOTALL)
+_CURRENCY_SNIFF = re.compile(r"[\$€£]")
+
+
+def repair_thead_cell_semantics(md: str) -> str:
+    """
+    Normalize header rows: cells inside <thead> should use <th>. Stray <td>
+    from OCR breaks rectangular header grids for parsers that expect <th> only
+    in thead. Institution-agnostic HTML repair only.
+    """
+    if not md or "<thead" not in md.lower():
+        return md
+
+    def fix_block(m: re.Match) -> str:
+        block = m.group(0)
+        block = re.sub(r"<td(\b[^>]*?>)", r"<th\1", block, flags=re.IGNORECASE)
+        block = re.sub(r"</td\s*>", "</th>", block, flags=re.IGNORECASE)
+        return block
+
+    return _THEAD_BLOCK.sub(fix_block, md)
+
+
+def _table_cell_plain_texts(full_table: str) -> List[str]:
+    return [_cell_plain_text(m.group(0)) for m in _CELL.finditer(full_table)]
+
+
+def strip_degenerate_html_tables(md: str) -> str:
+    """
+    Drop tables that are almost certainly non-ledger layout: all-empty grids,
+    or large sparse grids with no digits and no currency symbols (blank
+    worksheets / decorative boxes). Pattern-based only; no bank or product
+    names. Conservative thresholds to avoid removing real sparse tables.
+    """
+    if not md or "<table" not in md.lower():
+        return md
+
+    def should_drop(full: str) -> bool:
+        texts = _table_cell_plain_texts(full)
+        n = len(texts)
+        if n < 1:
+            return False
+        nonempty = sum(1 for t in texts if t.strip())
+        if nonempty == 0:
+            return True
+        joined = " ".join(texts)
+        compact = re.sub(r"\s+", " ", joined).strip()
+        L = len(compact)
+        financial = bool(re.search(r"\d", joined)) or bool(_CURRENCY_SNIFF.search(joined))
+        if financial:
+            return False
+        if n >= 12 and nonempty <= max(2, int(n * 0.06)):
+            return True
+        if n >= 8 and nonempty <= 1 and L < 80:
+            return True
+        return False
+
+    def repl_table(m: re.Match) -> str:
+        return "" if should_drop(m.group(0)) else m.group(0)
+
+    out = re.sub(
+        r"<table\b[^>]*>.*?</table>",
+        repl_table,
+        md,
+        flags=re.IGNORECASE | re.DOTALL,
+    )
+    return re.sub(r"\n{3,}", "\n\n", out)
+
+
 def looks_like_markdown_table(block: str) -> bool:
     lines = [ln.rstrip() for ln in block.strip().splitlines() if ln.strip()]
     if len(lines) < 2:
@@ -644,7 +718,10 @@ def light_stabilize_markdown(page_md: str) -> str:
         else:
             out_blocks.append(b)
     merged = close_unclosed_html("\n\n".join(out_blocks))
-    return stabilize_table_markup(merged, rounds=4)
+    merged = repair_thead_cell_semantics(merged)
+    merged = stabilize_table_markup(merged, rounds=4)
+    merged = strip_degenerate_html_tables(merged)
+    return merged
 
 
 def render_pdf_pages_to_images(pdf_path: str) -> Tuple[List[str], List[int]]:
@@ -784,6 +861,8 @@ def run_ocr(uploaded_file):
         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)
+            merged = repair_thead_cell_semantics(merged)
+            merged = strip_degenerate_html_tables(merged)
         return merged
 
     except Exception as e: