Update app.py

app.py

@@ -18,6 +18,8 @@ Primary goals for reconcile rate:
 - footer extraction enabled on all pages with deduplication guard (no double-print if body OCR already captured it)
 - Fix 4: cross-validate OCR table row counts against PDF text layer; inject missing duplicate rows
          (safe no-op for scanned PDFs and non-transaction pages)
+- Fix NF-1: extract Navy Federal "Summary of your deposit accounts" table from PDF text layer
+            using spatial word positions (GLM-OCR fails on this wide-column layout)
 """
 
 # Patch asyncio first (before Gradio imports it) to suppress Python 3.13 cleanup noise
@@ -2188,6 +2190,161 @@ def convert_plaintext_bank_sections(text: str) -> str:
 
     return "\n".join(out)
 
+# --------------------------
+# Navy Federal Summary Table extraction (Fix NF-1)
+# --------------------------
+
+def _extract_nfcu_summary_table(pdf_path: str, page_num: int) -> str:
+    """
+    Extract Navy Federal 'Summary of your deposit accounts' table from the PDF
+    text layer using spatial word positions.
+
+    GLM-OCR fails on this table because the five data columns are spread very
+    wide across the page and the account-name column has no visible border.
+    The PDF text layer contains the data perfectly — we read it with pdfplumber.
+
+    Detection guards (all must pass — safe no-op for all other banks):
+      1. A word 'Summary' must appear in the top 55% of the page height.
+      2. Words 'deposit' or 'accounts' must appear within 15pt of that word.
+
+    Returns HTML table string, or "" if not found or on any error.
+    """
+    try:
+        import pdfplumber
+        from collections import defaultdict as _defaultdict
+
+        with pdfplumber.open(pdf_path) as pdf:
+            if page_num >= len(pdf.pages):
+                return ""
+            page = pdf.pages[page_num]
+            words = page.extract_words()
+            page_h = float(page.height)
+
+            # Guard 1: find 'Summary' word in top 55% of page
+            summary_word = next(
+                (w for w in words
+                 if w['text'].lower() == 'summary' and w['top'] < page_h * 0.55),
+                None
+            )
+            if not summary_word:
+                return ""
+
+            # Guard 2: nearby words must confirm this is a deposit summary
+            nearby = [w['text'].lower() for w in words
+                      if abs(w['top'] - summary_word['top']) < 15]
+            if 'deposit' not in nearby and 'accounts' not in nearby:
+                return ""
+
+            # Band: start ~15pt below "Summary of..." heading, span ~115pt
+            y_start = summary_word['top'] + 15
+            y_end   = summary_word['top'] + 115
+
+            band_words = [w for w in words if y_start <= w['top'] <= y_end]
+            if not band_words:
+                return ""
+
+            # Group words into lines by y-bucket (5pt tolerance)
+            lines_by_y = _defaultdict(list)
+            for w in band_words:
+                bucket = round(w['top'] / 5) * 5
+                lines_by_y[bucket].append(w)
+
+            rows_raw = [sorted(lines_by_y[y], key=lambda w: w['x0'])
+                        for y in sorted(lines_by_y.keys())]
+
+            if len(rows_raw) < 3:
+                return ""
+
+            # Column centers from first two header rows
+            # (two-line header: "Previous Deposits/ Withdrawals/ Ending YTD" /
+            #                    "Balance  Credits   Debits       Balance Dividends")
+            header_words_flat = [w for r in rows_raw[:2] for w in r]
+            header_xs = sorted((w['x0'] + w['x1']) / 2 for w in header_words_flat)
+
+            col_centers = []
+            cluster = [header_xs[0]]
+            for x in header_xs[1:]:
+                if x - cluster[-1] > 30:
+                    col_centers.append(sum(cluster) / len(cluster))
+                    cluster = [x]
+                else:
+                    cluster.append(x)
+            col_centers.append(sum(cluster) / len(cluster))
+
+            def _assign_col(x_center):
+                return min(range(len(col_centers)),
+                           key=lambda i: abs(col_centers[i] - x_center))
+
+            # Build column labels by merging two header rows
+            col_labels = [''] * len(col_centers)
+            for r in rows_raw[:2]:
+                for w in r:
+                    xc = (w['x0'] + w['x1']) / 2
+                    ci = _assign_col(xc)
+                    sep = ' ' if col_labels[ci] else ''
+                    col_labels[ci] += sep + w['text']
+
+            # Data rows: each account has a name line + a values line
+            _MONEY_PAT = re.compile(r'^\$[\d,]+\.?\d*-?$|^[\d,]+\.?\d*-?$')
+
+            merged = []
+            current_name = []
+            current_vals = {}
+
+            for line in rows_raw[2:]:
+                texts = [w['text'] for w in line]
+                has_money = any(_MONEY_PAT.match(t) for t in texts)
+                is_totals = any(w['text'].lower() == 'totals' for w in line)
+
+                if has_money:
+                    # Values line — may also contain account number and/or 'Totals'
+                    val_words = [w for w in line
+                                 if not re.match(r'^\d{7,}$', w['text'])
+                                 and w['text'].lower() != 'totals']
+                    acct_words = [w for w in line if re.match(r'^\d{7,}$', w['text'])]
+
+                    for w in val_words:
+                        xc = (w['x0'] + w['x1']) / 2
+                        ci = _assign_col(xc)
+                        current_vals[ci] = w['text']
+
+                    name_str = ' '.join(current_name)
+                    if acct_words:
+                        name_str = (name_str + ' ' + acct_words[0]['text']).strip()
+                    if is_totals:
+                        name_str = 'Totals'
+
+                    merged.append((name_str, dict(current_vals)))
+                    current_name = []
+                    current_vals = {}
+                else:
+                    current_name.extend(texts)
+
+            if not merged:
+                return ""
+
+            n_cols = len(col_labels)
+            header_html = '<tr><th>Account</th>' + ''.join(
+                f'<th>{lbl}</th>' for lbl in col_labels) + '</tr>'
+
+            rows_html = []
+            for name, vals in merged:
+                row = f'<tr><td>{name}</td>'
+                for ci in range(n_cols):
+                    row += f'<td>{vals.get(ci, "")}</td>'
+                row += '</tr>'
+                rows_html.append(row)
+
+            return (
+                'Summary of your deposit accounts\n'
+                '<table>\n' + header_html + '\n' +
+                '\n'.join(rows_html) + '\n</table>'
+            )
+
+    except Exception as e:
+        log.warning("_extract_nfcu_summary_table failed (page %d): %s", page_num, e)
+        return ""
+
 def normalize_html_tables(text: str) -> str:
     """
     For every <table>...</table>:
@@ -2432,6 +2589,18 @@ def run_ocr(uploaded_file):
 
                 parts.append(stabilized)
 
+            # Fix NF-1: prepend Navy Federal "Summary of your deposit accounts" table.
+            # Uses pdfplumber spatial word positions to extract the wide-column summary
+            # table that GLM-OCR fails to parse correctly.
+            # Safe no-op for all non-NFCU PDFs (returns "" when guards don't match).
+            if is_pdf:
+                try:
+                    nfcu_summary = _extract_nfcu_summary_table(path, page_num)
+                    if nfcu_summary:
+                        parts.insert(0, nfcu_summary)
+                except Exception:
+                    pass
+
             # Footer extraction: PDF text layer -> band words -> OCR crop
             # Deduplication guard prevents double-printing when body OCR already captured it.
             if ENABLE_FOOTER_OCR and page_num < len(page_images):