Update app.py

app.py

@@ -1,59 +1,285 @@
+```python
 import gradio as gr
 import json
-from docling.document_converter import DocumentConverter, PdfFormatOption
-from docling.datamodel.pipeline_options import PdfPipelineOptions, TesseractCliOcrOptions
-from docling.datamodel.base_models import InputFormat
+import re
 import spaces
 
-# GPU decorator not really required for Docling OCR, but kept if you want
+from docling.document_converter import (
+    DocumentConverter,
+    PdfFormatOption
+)
+
+from docling.datamodel.pipeline_options import (
+    PdfPipelineOptions,
+    TesseractCliOcrOptions
+)
+
+from docling.datamodel.base_models import InputFormat
+
+
+# -----------------------------
+# Helpers
+# -----------------------------
+
+def clean_amount(x):
+    if not x:
+        return ""
+    return x.replace(",", "").strip()
+
+
+def convert_date(d):
+    m = re.match(r"(\d{2})-(\d{2})-(\d{2,4})", d)
+    if not m:
+        return d
+
+    dd, mm, yy = m.groups()
+
+    yyyy = "20" + yy if len(yy) == 2 else yy
+
+    return f"{yyyy}-{mm}-{dd}"
+
+
+def detect_voucher_type(text):
+    text = text.upper()
+
+    receipt_words = [
+        "CR",
+        "DEPOSIT",
+        "SUBSIDY",
+        "INTEREST",
+        "CREDIT",
+        "NEFT",
+        "IMPS",
+        "RTGS"
+    ]
+
+    for word in receipt_words:
+        if word in text:
+            return "Receipt"
+
+    return "Payment"
+
+
+# -----------------------------
+# Transaction Extraction
+# -----------------------------
+
+def extract_transactions(doc_dict):
+
+    transactions = []
+
+    tables = doc_dict.get("tables", [])
+
+    for table in tables:
+
+        cells = table.get("data", {}).get("table_cells", [])
+
+        grouped_rows = {}
+
+        for cell in cells:
+            row_index = cell.get("start_row_offset_idx")
+
+            grouped_rows.setdefault(row_index, []).append(cell)
+
+        for _, row_cells in sorted(grouped_rows.items()):
+
+            row_text = " ".join(
+                c.get("text", "") for c in row_cells
+            )
+
+            date_match = re.search(
+                r"\d{2}-\d{2}-\d{2,4}",
+                row_text
+            )
+
+            if not date_match:
+                continue
+
+            amounts = re.findall(
+                r"\d{1,3}(?:,\d{3})*(?:\.\d{2})|\d+\.\d{2}",
+                row_text
+            )
+
+            if len(amounts) < 2:
+                continue
+
+            date = convert_date(date_match.group(0))
+
+            amount = clean_amount(amounts[-2])
+
+            closing_balance = clean_amount(amounts[-1])
+
+            narration = row_text
+
+            narration = narration.replace(
+                date_match.group(0),
+                ""
+            )
+
+            for amt in amounts[-2:]:
+                narration = narration.replace(amt, "")
+
+            narration = re.sub(
+                r"\s+",
+                " ",
+                narration
+            ).strip()
+
+            transactions.append({
+                "date": date,
+                "description": narration[:80],
+                "raw_narration": narration,
+                "cheque_reference": "",
+                "voucher_type": detect_voucher_type(narration),
+                "amount": amount,
+                "closing_balance": closing_balance
+            })
+
+    return {
+        "success": True,
+        "total_transactions": len(transactions),
+        "transactions": transactions
+    }
+
+
+# -----------------------------
+# Main Convert Function
+# -----------------------------
+
 @spaces.GPU
 def convert_document(file, output_format):
-    # Configure OCR pipeline
-    pdf_opts = PdfPipelineOptions(
-        do_ocr=True,
-        ocr_options=TesseractCliOcrOptions(lang=["eng"])  # or ["eng","ara"] if needed
-    )
 
-    # Correct way: pass options via format_options
-    converter = DocumentConverter(
-        format_options={
-            InputFormat.PDF: PdfFormatOption(pipeline_options=pdf_opts)
+    if file is None:
+        return "No file uploaded", {}
+
+    try:
+
+        pdf_opts = PdfPipelineOptions(
+            do_ocr=True,
+            ocr_options=TesseractCliOcrOptions(
+                lang=["eng"]
+            )
+        )
+
+        converter = DocumentConverter(
+            format_options={
+                InputFormat.PDF:
+                PdfFormatOption(
+                    pipeline_options=pdf_opts
+                )
+            }
+        )
+
+        result = converter.convert(file.name)
+
+        doc = result.document
+
+        # Markdown
+        if output_format == "Markdown":
+
+            converted_text = doc.export_to_markdown()
+
+        # Raw JSON
+        elif output_format == "JSON":
+
+            converted_text = json.dumps(
+                doc.export_to_dict(),
+                indent=2,
+                ensure_ascii=False
+            )
+
+        # Clean Transaction JSON
+        elif output_format == "Bank Transaction JSON":
+
+            tx_json = extract_transactions(
+                doc.export_to_dict()
+            )
+
+            converted_text = json.dumps(
+                tx_json,
+                indent=2,
+                ensure_ascii=False
+            )
+
+        else:
+            converted_text = "Unsupported format"
+
+        metadata = {
+            "status": "success",
+            "pages": len(
+                getattr(doc, "pages", [])
+            ),
+            "output_format": output_format
         }
-    )
 
-    # Convert document
-    result = converter.convert(file.name)
+        return converted_text, metadata
 
-    # Choose output format safely
-    if output_format == "Markdown":
-        converted_text = result.document.export_to_markdown()
-    elif output_format == "JSON":
-        converted_text = result.document.export_to_dict()
-    else:
-        converted_text = "⚠️ Unsupported format"
+    except Exception as e:
 
-    # Metadata as JSON-friendly dict
-    metadata = {"Available Attributes": dir(result.document)}
+        return (
+            f"ERROR: {str(e)}",
+            {
+                "status": "error"
+            }
+        )
 
-    return converted_text, metadata
 
+# -----------------------------
+# UI
+# -----------------------------
 
 with gr.Blocks() as app:
-    gr.Markdown("# 📄 Document Converter with Docling OCR")
-    gr.Markdown("Upload a PDF, choose the output format, and get the converted text + metadata.")
+
+    gr.Markdown(
+        "# 📄 Docling OCR + Bank Statement Extractor"
+    )
+
+    gr.Markdown(
+        "Upload PDF and extract Markdown, JSON, or clean bank transactions."
+    )
 
     with gr.Row():
-        file_input = gr.File(label="Upload PDF", file_types=[".pdf"])
-        format_input = gr.Radio(["Markdown", "JSON"], label="Choose Output Format")
 
-    output_text = gr.Textbox(label="Converted Document", lines=20)
-    output_metadata = gr.JSON(label="Metadata")
+        file_input = gr.File(
+            label="Upload PDF",
+            file_types=[".pdf"]
+        )
+
+        format_input = gr.Radio(
+            [
+                "Markdown",
+                "JSON",
+                "Bank Transaction JSON"
+            ],
+            value="Bank Transaction JSON",
+            label="Choose Output Format"
+        )
+
+    output_text = gr.Textbox(
+        label="Converted Output",
+        lines=25
+    )
+
+    output_metadata = gr.JSON(
+        label="Metadata"
+    )
+
+    convert_button = gr.Button(
+        "Convert"
+    )
 
-    convert_button = gr.Button("Convert")
     convert_button.click(
         fn=convert_document,
-        inputs=[file_input, format_input],
-        outputs=[output_text, output_metadata]
+        inputs=[
+            file_input,
+            format_input
+        ],
+        outputs=[
+            output_text,
+            output_metadata
+        ],
+        api_name="/convert_document"
     )
 
 app.launch(debug=True)
+```