Update app.py

app.py

@@ -87,37 +87,28 @@ def _resize_for_inference(img):
     return img.resize(new_size, Image.LANCZOS)
 
 
-def _build_table(rows: List[str]) -> str:
-    parsed = []
-
-    for row in rows:
-        parts = re.split(r"\s{2,}", row.strip())
-        if len(parts) >= 3:
-            date = parts[0]
-            amount = parts[-1] if re.search(r"\d+\.\d{2}", parts[-1]) else ""
-            desc = " ".join(parts[1:-1]) if amount else " ".join(parts[1:])
-            parsed.append((date, desc, amount))
-
-    if not parsed:
-        return "\n".join(rows)
-
+def _build_table_from_entries(entries: List[dict]) -> str:
+    if not entries:
+        return ""
     table = [
-        "| POSTING DATE | DESCRIPTION | AMOUNT |",
-        "| :--- | :--- | ---: |",
+        "| Date | Description | Amount |",
+        "|------|------------|--------|",
     ]
-    for date, desc, amount in parsed:
-        table.append(f"| {date} | {desc} | {amount} |")
+    for row in entries:
+        table.append(f"| {row['date']} | {row['description']} | {row['amount']} |")
     return "\n".join(table)
 
 
 def _normalize_transactions(text: str) -> str:
     """
-    Convert loose transaction lines into structured markdown tables.
+    Convert loose transaction lines into structured markdown tables using:
+    MM/DD ... amount
     """
     lines = text.split("\n")
     result: List[str] = []
     table_buffer: List[str] = []
     in_section = False
+    pattern = re.compile(r"(\d{2}/\d{2})\s+(.*?)\s+([\d,]+\.\d{2})$")
 
     for line in lines:
         if re.search(r"POSTING DATE.*DESCRIPTION.*AMOUNT", line, re.IGNORECASE):
@@ -127,7 +118,19 @@ def _normalize_transactions(text: str) -> str:
 
         if in_section and (line.strip() == "" or line.strip().startswith("Subtotal")):
             if table_buffer:
-                result.append(_build_table(table_buffer))
+                clean_rows = []
+                for raw in table_buffer:
+                    normalized = " ".join(raw.split())
+                    match = pattern.search(normalized)
+                    if match:
+                        date, desc, amount = match.groups()
+                        clean_rows.append(
+                            {"date": date, "description": desc, "amount": amount}
+                        )
+                if clean_rows:
+                    result.append(_build_table_from_entries(clean_rows))
+                else:
+                    result.extend(table_buffer)
                 table_buffer = []
             in_section = False
             result.append(line)
@@ -139,7 +142,19 @@ def _normalize_transactions(text: str) -> str:
             result.append(line)
 
     if table_buffer:
-        result.append(_build_table(table_buffer))
+        clean_rows = []
+        for raw in table_buffer:
+            normalized = " ".join(raw.split())
+            match = pattern.search(normalized)
+            if match:
+                date, desc, amount = match.groups()
+                clean_rows.append(
+                    {"date": date, "description": desc, "amount": amount}
+                )
+        if clean_rows:
+            result.append(_build_table_from_entries(clean_rows))
+        else:
+            result.extend(table_buffer)
 
     return "\n".join(result)
 
@@ -162,7 +177,38 @@ def _html_to_markdown_tables(text: str) -> str:
     try:
         from bs4 import BeautifulSoup
     except Exception:
-        return text
+        # Fallback when bs4 is unavailable: regex-based conversion for simple tables.
+        table_re = re.compile(r"<table[\s\S]*?</table>", re.IGNORECASE)
+        row_re = re.compile(r"<tr[\s\S]*?</tr>", re.IGNORECASE)
+        cell_re = re.compile(r"<t[dh][^>]*>([\s\S]*?)</t[dh]>", re.IGNORECASE)
+        tag_re = re.compile(r"<[^>]+>")
+
+        def _clean_cell(cell: str) -> str:
+            cell = re.sub(r"<br\s*/?>", " ", cell, flags=re.IGNORECASE)
+            cell = tag_re.sub(" ", cell)
+            cell = cell.replace("&nbsp;", " ").replace("&amp;", "&")
+            cell = re.sub(r"\s+", " ", cell).strip()
+            return cell
+
+        def _convert(table_html: str) -> str:
+            rows = []
+            for tr in row_re.findall(table_html):
+                cols = [_clean_cell(c) for c in cell_re.findall(tr)]
+                cols = [c for c in cols if c != ""]
+                if cols:
+                    rows.append(cols)
+            if not rows:
+                return table_html
+            width = max(len(r) for r in rows)
+            norm = [r + [""] * (width - len(r)) for r in rows]
+            md = []
+            md.append("| " + " | ".join(norm[0]) + " |")
+            md.append("| " + " | ".join(["---"] * width) + " |")
+            for r in norm[1:]:
+                md.append("| " + " | ".join(r) + " |")
+            return "\n".join(md)
+
+        return table_re.sub(lambda m: _convert(m.group(0)), text)
 
     soup = BeautifulSoup(text, "html.parser")
 
@@ -188,8 +234,39 @@ def _html_to_markdown_tables(text: str) -> str:
     return str(soup)
 
 
+def _remove_prompt_echo_artifacts(text: str) -> str:
+    """
+    Remove model prompt-echo garbage blocks such as repeated:
+    'N) Keep left-most amount values.' / 'N) Keep right-most amount values.'
+    """
+    lines = text.split("\n")
+    cleaned: List[str] = []
+    keep_line_re = re.compile(
+        r"^\s*\d+\)\s*Keep\s+(left-most|right-most)\s+amount\s+values\.?\s*$",
+        re.IGNORECASE,
+    )
+    repeat_run = 0
+
+    for line in lines:
+        if keep_line_re.match(line):
+            repeat_run += 1
+            continue
+        # Also drop explicit prompt/rules echoes if they appear as plain output.
+        if re.match(r"^\s*Document Parsing to markdown\.?\s*$", line, re.IGNORECASE):
+            continue
+        if re.match(r"^\s*Rules:\s*$", line, re.IGNORECASE):
+            continue
+        cleaned.append(line)
+
+    # If there was a long repeated run, ensure dangling separator spacing stays clean.
+    text = "\n".join(cleaned)
+    text = re.sub(r"\n{4,}", "\n\n\n", text)
+    return text
+
+
 def _clean_markdown(text: str) -> str:
     """Post-process markdown to fix table formatting and section structure."""
+    text = _remove_prompt_echo_artifacts(text)
     text = _html_to_markdown_tables(text)
     text = _fix_missing_amounts(text)
     text = _normalize_transactions(text)
@@ -246,12 +323,9 @@ def _infer_image(image_path: str) -> str:
                 {
                     "type": "text",
                     "text": (
-                        "Document Parsing to markdown.\n"
-                        "Rules:\n"
-                        "1) Preserve rows exactly in reading order.\n"
-                        "2) Keep transaction blocks as markdown tables.\n"
-                        "3) Do not invent rows or sample/template data.\n"
-                        "4) Keep right-most amount values."
+                        "Extract document text as markdown only. "
+                        "Do not include instructions, examples, or template rows. "
+                        "Preserve transaction lines exactly."
                     ),
                 },
             ],