Upload folder using huggingface_hub

app.py

@@ -1,17 +1,22 @@
-# app.py
-# High-accuracy bill extraction API with optional Amazon Textract / Google Vision + robust Tesseract fallback.
-# Usage:
-#   export OCR_ENGINE=textract   # or "vision" or "tesseract"
-#   export AWS_REGION=us-east-1  # required for Textract
-#   export GEMINI_API_KEY=...    # optional
-#   uvicorn app:app --host 0.0.0.0 --port 8080
+# Enhanced Bill Extraction API
+# Designed for Bajaj Datathon: accurate line item + subtotal + total extraction
+# 
+# Key improvements:
+# 1. Explicit subtotal/total detection and preservation
+# 2. Double-count prevention via fingerprinting
+# 3. Item-sum vs bill-total validation
+# 4. Confidence scoring and anomaly detection
+# 5. Enhanced preprocessing for table structures
+# 6. Gemini-powered structural validation
 
 import os
 import re
 import json
 import logging
 from io import BytesIO
-from typing import List, Dict, Any, Optional, Tuple
+from typing import List, Dict, Any, Optional, Tuple, Set
+from dataclasses import dataclass, asdict
+from collections import defaultdict
 
 from fastapi import FastAPI
 from pydantic import BaseModel
@@ -35,23 +40,22 @@ try:
 except Exception:
     vision = None
 
-# Optional: Google Gemini SDK (if available)
 try:
     import google.generativeai as genai
 except Exception:
     genai = None
 
 # -------------------------------------------------------------------------
-# Configuration and logging
+# Configuration
 # -------------------------------------------------------------------------
-OCR_ENGINE = os.getenv("OCR_ENGINE", "textract").lower()   # 'textract' | 'vision' | 'tesseract'
+OCR_ENGINE = os.getenv("OCR_ENGINE", "tesseract").lower()
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-GEMINI_MODEL_NAME = os.getenv("GEMINI_MODEL_NAME", "gemini-2.5-flash")
+GEMINI_MODEL_NAME = os.getenv("GEMINI_MODEL_NAME", "gemini-2.0-flash")
 AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
-TESSERACT_PSM = os.getenv("TESSERACT_PSM", "6")  # page segmentation mode default
+TESSERACT_PSM = os.getenv("TESSERACT_PSM", "6")
 
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("bill-extractor")
+logger = logging.getLogger("bill-extractor-v2")
 
 if GEMINI_API_KEY and genai is not None:
     try:
@@ -60,138 +64,312 @@ if GEMINI_API_KEY and genai is not None:
     except Exception as e:
         logger.warning("Gemini config failed: %s", e)
 
-# Boto3 textract client (lazy init)
+# Lazy clients
 _textract_client = None
+_vision_client = None
+
 def textract_client():
     global _textract_client
     if _textract_client is None:
         if boto3 is None:
-            raise RuntimeError("boto3 not installed but OCR_ENGINE=textract requested")
+            raise RuntimeError("boto3 not installed")
         _textract_client = boto3.client("textract", region_name=AWS_REGION)
     return _textract_client
 
-# Google Vision client (lazy)
-_vision_client = None
 def vision_client():
     global _vision_client
     if _vision_client is None:
         if vision is None:
-            raise RuntimeError("google-cloud-vision not installed but OCR_ENGINE=vision requested")
+            raise RuntimeError("google-cloud-vision not installed")
         _vision_client = vision.ImageAnnotatorClient()
     return _vision_client
 
 # -------------------------------------------------------------------------
-# Request model
+# Data Models
 # -------------------------------------------------------------------------
-app = FastAPI(title="Bajaj Datathon - Bill Extractor (high-accuracy)")
-
-class BillRequest(BaseModel):
-    document: str  # file://local_path or http(s) url
+@dataclass
+class BillLineItem:
+    """Represents a single line item in a bill"""
+    item_name: str
+    item_quantity: float = 1.0
+    item_rate: float = 0.0
+    item_amount: float = 0.0
+    confidence: float = 1.0  # 0-1 confidence score
+    source_row: str = ""  # raw OCR text for debugging
+    is_description_continuation: bool = False  # multi-line item flag
+    
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        d.pop("source_row", None)  # exclude raw text from output
+        d.pop("is_description_continuation", None)
+        return d
+
+@dataclass
+class BillTotal:
+    """Subtotal and total information"""
+    subtotal_amount: Optional[float] = None
+    tax_amount: Optional[float] = None
+    discount_amount: Optional[float] = None
+    final_total_amount: Optional[float] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+@dataclass
+class ExtractedPage:
+    """Page-level extraction result"""
+    page_no: int
+    page_type: str  # "Bill Detail", "Header", "Footer", etc.
+    line_items: List[BillLineItem]
+    bill_totals: BillTotal
+    page_confidence: float = 1.0
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "page_no": self.page_no,
+            "page_type": self.page_type,
+            "line_items": [item.to_dict() for item in self.line_items],
+            "bill_totals": self.bill_totals.to_dict(),
+            "page_confidence": round(self.page_confidence, 3),
+        }
 
 # -------------------------------------------------------------------------
-# Helpers (numbers, cleaning, OCR preprocessing)
+# Regular Expressions (Enhanced)
 # -------------------------------------------------------------------------
 NUM_RE = re.compile(r"[-+]?\d{1,3}(?:[,0-9]*)(?:\.\d+)?")
+
+# Total/Subtotal keywords (improved detection)
 TOTAL_KEYWORDS = re.compile(
-    r"(grand\s*total|net\s*payable|total\s*amount|amount\s*payable|bill\s*amount|final\s*amount|balance\s*due|sub\s*total|subtotal|round\s*off)",
-    re.I,
+    r"\b(grand\s+total|net\s+payable|total\s+(?:amount|due)|amount\s+payable|bill\s+amount|"
+    r"final\s+(?:amount|total)|balance\s+due|amount\s+due|total\s+payable|payable)\b",
+    re.I
+)
+SUBTOTAL_KEYWORDS = re.compile(
+    r"\b(sub\s*[\-\s]?total|subtotal|sub\s+total|items\s+total|line\s+items\s+total)\b",
+    re.I
+)
+TAX_KEYWORDS = re.compile(
+    r"\b(tax|gst|vat|sgst|cgst|igst|sales\s+tax|service\s+tax)\b",
+    re.I
+)
+DISCOUNT_KEYWORDS = re.compile(
+    r"\b(discount|rebate|deduction)\b",
+    re.I
+)
+FOOTER_KEYWORDS = re.compile(
+    r"(page|printed\s+on|printed|date|time|signature|authorized|terms|conditions)",
+    re.I
 )
-FOOTER_KEYWORDS = re.compile(r"(page|printed on|printed:|date:|time:|am|pm)", re.I)
 
 HEADER_KEYWORDS = [
-    "description", "qty", "hrs", "rate", "discount", "net", "amt", "amount",
-    "consultation", "address", "sex", "age", "mobile", "patient", "category",
-    "doctor", "dr", "invoice", "bill", "subtotal", "total", "charges", "service"
+    "description", "qty", "qty/hrs", "hrs", "rate", "unit price", "discount", 
+    "net", "amt", "amount", "price", "total", "sl.no", "s.no", "item", "service",
+    "consultation", "patient", "invoice", "bill", "charges"
 ]
-HEADER_PHRASES = [
-    "description qty / hrs consultation rate discount net amt",
-    "description qty / hrs rate discount net amt",
-]
-HEADER_PHRASES = [h.lower() for h in HEADER_PHRASES]
 
+# -------------------------------------------------------------------------
+# Text Cleaning & Normalization
+# -------------------------------------------------------------------------
 def sanitize_ocr_text(s: Optional[str]) -> str:
+    """Deep clean OCR text"""
     if not s:
         return ""
     s = s.replace("\u2014", "-").replace("\u2013", "-")
+    s = s.replace("\u00A0", " ")  # nbsp
     s = re.sub(r"[^\x09\x0A\x0D\x20-\x7E]", " ", s)
     s = s.replace("\r\n", "\n").replace("\r", "\n")
     s = re.sub(r"[ \t]+", " ", s)
-    # common OCR corrections
-    s = re.sub(r"\bqiy\b", "qty", s, flags=re.I)
-    s = re.sub(r"\bdeseription\b", "description", s, flags=re.I)
+    # OCR corrections
+    s = re.sub(r"\b(qiy|qty|oty|gty)\b", "qty", s, flags=re.I)
+    s = re.sub(r"\b(deseription|descriptin|desription)\b", "description", s, flags=re.I)
     return s.strip()
 
-def normalize_num_str(s: Optional[str]) -> Optional[float]:
+def normalize_num_str(s: Optional[str], allow_zero: bool = False) -> Optional[float]:
+    """Robust number parsing"""
     if s is None:
         return None
     s = str(s).strip()
     if s == "":
         return None
-    s = re.sub(r"[^\d\-\+\,\.\(\)]", "", s)
+    
+    # Handle parentheses (negative indicator)
     negative = False
     if s.startswith("(") and s.endswith(")"):
         negative = True
         s = s[1:-1]
+    
+    # Remove non-numeric chars except decimal/comma
+    s = re.sub(r"[^\d\-\+\,\.\(\)]", "", s)
     s = s.replace(",", "")
+    
     if s in ("", "-", "+"):
         return None
+    
     try:
         val = float(s)
-        return -val if negative else val
-    except Exception:
-        try:
-            return float(s.replace(" ", ""))
-        except Exception:
+        val = -val if negative else val
+        if val == 0 and not allow_zero:
             return None
+        return val
+    except Exception:
+        return None
 
 def is_numeric_token(t: Optional[str]) -> bool:
+    """Check if token is numeric"""
     return bool(t and NUM_RE.search(str(t)))
 
-def clean_name_text(s: str) -> str:
-    s = s.replace("—", "-")
+def clean_item_name(s: str) -> str:
+    """Clean item description text"""
+    s = s.replace("—", "-").replace("–", "-")
     s = re.sub(r"\s+", " ", s)
-    s = s.strip(" -:,.=")
-    s = re.sub(r"\s+x$", "", s, flags=re.I)
-    s = re.sub(r"[\)\}\]]+$", "", s)
+    s = s.strip(" -:,.=()[]{}|\\")
     s = re.sub(r"\bOR\b", "DR", s)  # OCR OR -> DR
     return s.strip()
 
 # -------------------------------------------------------------------------
-# Image preprocessing helpers (for Tesseract pipeline)
+# Item Fingerprinting (for deduplication)
+# -------------------------------------------------------------------------
+def item_fingerprint(item: BillLineItem) -> Tuple[str, float]:
+    """Create fingerprint for deduplication"""
+    name_norm = re.sub(r"\s+", " ", item.item_name.lower()).strip()[:100]
+    amount_rounded = round(float(item.item_amount), 2)
+    return (name_norm, amount_rounded)
+
+def dedupe_items_advanced(items: List[BillLineItem]) -> List[BillLineItem]:
+    """
+    Remove duplicates while preserving highest-confidence versions.
+    Handles multi-line descriptions by checking sequential items.
+    """
+    if not items:
+        return []
+    
+    # Remove exact duplicates (same fingerprint)
+    seen: Dict[Tuple, BillLineItem] = {}
+    for item in items:
+        fp = item_fingerprint(item)
+        if fp not in seen or item.confidence > seen[fp].confidence:
+            seen[fp] = item
+    
+    # Remove high-similarity continuation rows (likely description wrapping)
+    final = []
+    for item in seen.values():
+        if item.is_description_continuation:
+            # Check if very similar to previous item
+            if final and abs(float(final[-1].item_amount) - float(item.item_amount)) < 0.01:
+                # Likely continuation; merge
+                final[-1].item_name = (final[-1].item_name + " " + item.item_name).strip()
+                continue
+        final.append(item)
+    
+    return final
+
+# -------------------------------------------------------------------------
+# Total/Subtotal Detection
+# -------------------------------------------------------------------------
+def detect_totals_in_rows(rows: List[List[Dict[str, Any]]]) -> Tuple[Optional[float], Optional[float], Optional[float], Optional[float]]:
+    """
+    Scan rows for subtotal, tax, discount, final total.
+    Returns: (subtotal, tax, discount, final_total)
+    """
+    subtotal = None
+    tax = None
+    discount = None
+    final_total = None
+    
+    rows_text = []
+    for row in rows:
+        row_text = " ".join([c["text"] for c in row])
+        rows_text.append((row_text, row))
+    
+    # Scan for keywords
+    for row_text, row in rows_text:
+        row_lower = row_text.lower()
+        tokens = row_text.split()
+        
+        # Extract number from row
+        amounts = []
+        for t in tokens:
+            if is_numeric_token(t):
+                v = normalize_num_str(t, allow_zero=True)
+                if v is not None:
+                    amounts.append(v)
+        
+        if not amounts:
+            continue
+        
+        # Use rightmost/largest amount typically
+        amount = max(amounts)
+        
+        # Keyword matching
+        if FINAL_TOTAL_KEYWORDS.search(row_lower):
+            final_total = amount
+        elif SUBTOTAL_KEYWORDS.search(row_lower):
+            subtotal = amount
+        elif TAX_KEYWORDS.search(row_lower):
+            tax = amount
+        elif DISCOUNT_KEYWORDS.search(row_lower):
+            discount = amount
+    
+    return subtotal, tax, discount, final_total
+
+FINAL_TOTAL_KEYWORDS = re.compile(
+    r"\b(grand\s+total|final\s+(?:total|amount)|total\s+(?:due|payable|amount)|"
+    r"net\s+payable|amount\s+(?:due|payable)|balance\s+due|payable)\b",
+    re.I
+)
+
+# -------------------------------------------------------------------------
+# Image Preprocessing
 # -------------------------------------------------------------------------
 def pil_to_cv2(img: Image.Image) -> Any:
+    """Convert PIL to OpenCV"""
     arr = np.array(img)
     if arr.ndim == 2:
         return arr
     return cv2.cvtColor(arr, cv2.COLOR_RGB2BGR)
 
 def preprocess_image_for_tesseract(pil_img: Image.Image, target_w: int = 1500) -> Any:
+    """Enhanced preprocessing for table-heavy documents"""
     pil_img = pil_img.convert("RGB")
     w, h = pil_img.size
+    
+    # Upscale if too small
     if w < target_w:
         scale = target_w / float(w)
         pil_img = pil_img.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
+    
     cv_img = pil_to_cv2(pil_img)
+    
+    # Grayscale
     if cv_img.ndim == 3:
         gray = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY)
     else:
         gray = cv_img
+    
+    # Denoise
     gray = cv2.fastNlMeansDenoising(gray, h=10)
+    
+    # Adaptive thresholding (better for tables with shadows)
     try:
         bw = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                    cv2.THRESH_BINARY, 41, 15)
     except Exception:
         _, bw = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
-    kernel = np.ones((1,1), np.uint8)
+    
+    # Morphological cleanup
+    kernel = np.ones((2, 2), np.uint8)
+    bw = cv2.morphologyEx(bw, cv2.MORPH_CLOSE, kernel)
     bw = cv2.morphologyEx(bw, cv2.MORPH_OPEN, kernel)
+    
     return bw
 
 def image_to_tsv_cells(cv_img: Any) -> List[Dict[str, Any]]:
-    # returns list of OCR 'cells' compatible with your parsing pipeline
+    """Extract OCR cells from image"""
     try:
         o = pytesseract.image_to_data(cv_img, output_type=Output.DICT, config=f"--psm {TESSERACT_PSM}")
     except Exception:
         o = pytesseract.image_to_data(cv_img, output_type=Output.DICT)
+    
     cells = []
     n = len(o.get("text", []))
     for i in range(n):
@@ -201,28 +379,39 @@ def image_to_tsv_cells(cv_img: Any) -> List[Dict[str, Any]]:
         txt = str(raw).strip()
         if not txt:
             continue
+        
         try:
             conf_raw = o.get("conf", [])[i]
             conf = float(conf_raw) if conf_raw not in (None, "", "-1") else -1.0
         except Exception:
             conf = -1.0
+        
         left = int(o.get("left", [0])[i])
         top = int(o.get("top", [0])[i])
         width = int(o.get("width", [0])[i])
         height = int(o.get("height", [0])[i])
         center_y = top + height / 2.0
         center_x = left + width / 2.0
-        cells.append({"text": txt, "conf": conf, "left": left, "top": top,
-                      "width": width, "height": height, "center_y": center_y, "center_x": center_x})
+        
+        cells.append({
+            "text": txt,
+            "conf": max(0.0, conf) / 100.0,  # normalize to 0-1
+            "left": left, "top": top, "width": width, "height": height,
+            "center_x": center_x, "center_y": center_y
+        })
+    
     return cells
 
 def group_cells_into_rows(cells: List[Dict[str, Any]], y_tolerance: int = 12) -> List[List[Dict[str, Any]]]:
+    """Group cells by horizontal position (rows)"""
     if not cells:
         return []
+    
     sorted_cells = sorted(cells, key=lambda c: (c["center_y"], c["center_x"]))
     rows = []
     current = [sorted_cells[0]]
     last_y = sorted_cells[0]["center_y"]
+    
     for c in sorted_cells[1:]:
         if abs(c["center_y"] - last_y) <= y_tolerance:
             current.append(c)
@@ -231,72 +420,31 @@ def group_cells_into_rows(cells: List[Dict[str, Any]], y_tolerance: int = 12) ->
             rows.append(sorted(current, key=lambda cc: cc["left"]))
             current = [c]
             last_y = c["center_y"]
+    
     if current:
         rows.append(sorted(current, key=lambda cc: cc["left"]))
+    
     return rows
 
-def merge_multiline_names(rows: List[List[Dict[str, Any]]]) -> List[List[Dict[str, Any]]]:
-    if not rows:
-        return rows
-    merged = []
-    i = 0
-    while i < len(rows):
-        row = rows[i]
-        tokens = [c["text"] for c in row]
-        has_num = any(is_numeric_token(t) for t in tokens)
-        if not has_num and i + 1 < len(rows):
-            next_row = rows[i+1]
-            next_tokens = [c["text"] for c in next_row]
-            next_has_num = any(is_numeric_token(t) for t in next_tokens)
-            if next_has_num and len(tokens) >= 2 and len([t for t in next_tokens if not is_numeric_token(t)]) <= 3:
-                merged_row = []
-                min_left = min((c["left"] for c in next_row), default=0)
-                offset = 10
-                for c in row:
-                    newc = c.copy()
-                    newc["left"] = min_left - offset
-                    newc["center_x"] = newc["left"] + newc.get("width", 0) / 2.0
-                    merged_row.append(newc)
-                    offset += 10
-                merged_row.extend(next_row)
-                merged.append(sorted(merged_row, key=lambda cc: cc["left"]))
-                i += 2
-                continue
-        if not has_num and i + 1 < len(rows):
-            next_row = rows[i+1]
-            next_tokens = [c["text"] for c in next_row]
-            next_has_num = any(is_numeric_token(t) for t in next_tokens)
-            if not next_has_num and len(tokens) <= 3 and len(next_tokens) <= 3:
-                merged_row = []
-                min_left = min((c["left"] for c in next_row + row), default=0)
-                offset = 10
-                for c in row + next_row:
-                    newc = c.copy()
-                    if newc["left"] > min_left:
-                        newc["left"] = newc["left"]
-                    else:
-                        newc["left"] = min_left - offset
-                    newc["center_x"] = newc["left"] + newc.get("width", 0) / 2.0
-                    merged_row.append(newc)
-                    offset += 5
-                merged.append(sorted(merged_row, key=lambda cc: cc["left"]))
-                i += 2
-                continue
-        merged.append(row)
-        i += 1
-    return merged
-
+# -------------------------------------------------------------------------
+# Column Detection (Enhanced)
+# -------------------------------------------------------------------------
 def detect_numeric_columns(cells: List[Dict[str, Any]], max_columns: int = 6) -> List[float]:
+    """Detect x-positions of numeric columns"""
     xs = [c["center_x"] for c in cells if is_numeric_token(c["text"])]
     if not xs:
         return []
-    xs = sorted(xs)
+    
+    xs = sorted(set(xs))
     if len(xs) == 1:
-        return [xs[0]]
+        return xs
+    
+    # Cluster columns by gap analysis
     gaps = [xs[i+1] - xs[i] for i in range(len(xs)-1)]
     mean_gap = float(np.mean(gaps))
     std_gap = float(np.std(gaps)) if len(gaps) > 1 else 0.0
-    gap_thresh = max(28.0, mean_gap + 0.6 * std_gap)
+    gap_thresh = max(35.0, mean_gap + 0.7 * std_gap)
+    
     clusters = []
     curr = [xs[0]]
     for i, g in enumerate(gaps):
@@ -306,596 +454,414 @@ def detect_numeric_columns(cells: List[Dict[str, Any]], max_columns: int = 6) ->
         else:
             curr.append(xs[i+1])
     clusters.append(curr)
+    
     centers = [float(np.median(c)) for c in clusters]
     if len(centers) > max_columns:
         centers = centers[-max_columns:]
+    
     return sorted(centers)
 
 def assign_token_to_column(token_x: float, column_centers: List[float]) -> Optional[int]:
+    """Find closest column index for token"""
     if not column_centers:
         return None
     distances = [abs(token_x - cx) for cx in column_centers]
     return int(np.argmin(distances))
 
 # -------------------------------------------------------------------------
-# Parsing pipeline (shared)
+# Row Parsing (Enhanced for accuracy)
 # -------------------------------------------------------------------------
-def parse_rows_with_columns(rows: List[List[Dict[str, Any]]], page_cells: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    parsed_items = []
-    rows = merge_multiline_names(rows)
+def parse_rows_with_columns(
+    rows: List[List[Dict[str, Any]]],
+    page_cells: List[Dict[str, Any]],
+    page_text: str = ""
+) -> List[BillLineItem]:
+    """
+    Parse rows into line items with improved accuracy.
+    Handles multi-line descriptions and uncertain quantities.
+    """
+    items = []
     column_centers = detect_numeric_columns(page_cells, max_columns=6)
-
-    for row in rows:
+    
+    for row_idx, row in enumerate(rows):
         tokens = [c["text"] for c in row]
-        if not tokens:
-            continue
-        joined_lower = " ".join(tokens).lower()
-        if FOOTER_KEYWORDS.search(joined_lower) and not any(is_numeric_token(t) for t in tokens):
+        row_text = " ".join(tokens)
+        row_lower = row_text.lower()
+        
+        # Skip footers/headers
+        if FOOTER_KEYWORDS.search(row_lower) and not any(is_numeric_token(t) for t in tokens):
             continue
-        # require some numeric token (date-only rows excluded later)
-        if all(not is_numeric_token(t) for t in tokens):
+        
+        # Require at least one numeric token
+        if not any(is_numeric_token(t) for t in tokens):
             continue
-
+        
+        # Extract amounts
         numeric_values = []
         for t in tokens:
             if is_numeric_token(t):
-                v = normalize_num_str(t)
+                v = normalize_num_str(t, allow_zero=False)
                 if v is not None:
                     numeric_values.append(float(v))
-        numeric_values = sorted(list({int(x) if float(x).is_integer() else x for x in numeric_values}), reverse=True)
-
+        
+        if not numeric_values:
+            continue
+        
+        numeric_values = sorted(list(set(numeric_values)), reverse=True)
+        
+        # Column-based parsing
         if column_centers:
             left_text_parts = []
-            numeric_bucket_map = {i: [] for i in range(len(column_centers))}
+            numeric_buckets = {i: [] for i in range(len(column_centers))}
+            
             for c in row:
                 t = c["text"]
                 cx = c["center_x"]
+                conf = c.get("conf", 1.0)
+                
                 if is_numeric_token(t):
                     col_idx = assign_token_to_column(cx, column_centers)
                     if col_idx is None:
-                        numeric_bucket_map[len(column_centers) - 1].append(t)
-                    else:
-                        numeric_bucket_map[col_idx].append(t)
+                        col_idx = len(column_centers) - 1
+                    numeric_buckets[col_idx].append((t, conf))
                 else:
                     left_text_parts.append(t)
-            raw_name = " ".join(left_text_parts).strip()
-            name = clean_name_text(raw_name) if raw_name else ""
+            
+            item_name = " ".join(left_text_parts).strip()
+            item_name = clean_item_name(item_name) if item_name else "UNKNOWN"
+            
+            # Extract from columns (right-most is typically amount)
             num_cols = len(column_centers)
-            def get_bucket(idx):
-                vals = numeric_bucket_map.get(idx, [])
-                return vals[-1] if vals else None
-            amount = normalize_num_str(get_bucket(num_cols - 1)) if num_cols >= 1 else None
-            rate = normalize_num_str(get_bucket(num_cols - 2)) if num_cols >= 2 else None
-            qty = normalize_num_str(get_bucket(num_cols - 3)) if num_cols >= 3 else None
-
+            amount = None
+            rate = None
+            qty = None
+            
+            # Try rightmost column first (usually total amount)
+            if num_cols >= 1:
+                bucket = numeric_buckets.get(num_cols - 1, [])
+                if bucket:
+                    amt_str = bucket[-1][0]
+                    amount = normalize_num_str(amt_str, allow_zero=False)
+            
             if amount is None:
-                for t in reversed(tokens):
-                    if is_numeric_token(t):
-                        amount = normalize_num_str(t)
-                        if amount is not None:
-                            break
-
-            # infer rate and qty heuristics
-            if amount is not None and numeric_values:
+                # Fallback: take largest numeric value
+                for v in numeric_values:
+                    if v > 0:
+                        amount = v
+                        break
+            
+            # Try second-to-right for rate
+            if num_cols >= 2:
+                bucket = numeric_buckets.get(num_cols - 2, [])
+                if bucket:
+                    rate = normalize_num_str(bucket[-1][0], allow_zero=False)
+            
+            # Try third-to-right for quantity
+            if num_cols >= 3:
+                bucket = numeric_buckets.get(num_cols - 3, [])
+                if bucket:
+                    qty = normalize_num_str(bucket[-1][0], allow_zero=False)
+            
+            # Smart qty/rate inference
+            if amount and not qty and not rate and numeric_values:
                 for cand in numeric_values:
-                    try:
-                        cand_float = float(cand)
-                    except:
-                        continue
-                    if cand_float <= 1.0:
-                        continue
-                    if amount <= 5 and cand_float < 1.0:
-                        continue
-                    if cand_float >= amount:
-                        continue
-                    ratio = amount / cand_float if cand_float else None
-                    if ratio is None:
+                    if cand <= 0.1 or cand >= amount:
                         continue
+                    ratio = amount / cand
                     r = round(ratio)
-                    if r < 1 or r > 200:
-                        continue
-                    if abs(ratio - r) <= max(0.03 * r, 0.15):
-                        if r <= 100:
-                            rate = cand_float
-                            qty = float(r)
-                            break
-
-            if (rate is None or rate == 0) and qty and qty != 0 and amount is not None:
-                try:
-                    candidate_rate = amount / qty
-                    if candidate_rate >= 1.0:
-                        rate = candidate_rate
-                except Exception:
-                    pass
-
+                    if 1 <= r <= 100 and abs(ratio - r) <= 0.15 * r:
+                        qty = float(r)
+                        rate = cand
+                        break
+            
+            # Derive missing values
+            if qty and rate is None and amount and amount != 0:
+                rate = amount / qty
+            elif rate and qty is None and amount and amount != 0:
+                qty = amount / rate
+            elif amount and qty and rate is None:
+                rate = amount / qty if qty != 0 else 0.0
+            
+            # Defaults
             if qty is None:
                 qty = 1.0
-
-            try:
-                amount = float(round(amount, 2))
-            except Exception:
-                continue
-            try:
-                rate = float(round(rate, 2)) if rate is not None else 0.0
-            except Exception:
+            if rate is None:
                 rate = 0.0
-            try:
-                qty = float(qty)
-            except Exception:
-                qty = 1.0
-
-            parsed_items.append({
-                "item_name": name if name else "UNKNOWN",
-                "item_amount": amount,
-                "item_rate": rate if rate is not None else 0.0,
-                "item_quantity": qty if qty is not None else 1.0,
-            })
+            if amount is None:
+                amount = qty * rate if qty and rate else 0.0
+            
+            # Finalize
+            if amount > 0:
+                confidence = np.mean([c.get("conf", 0.85) for c in row]) if row else 0.85
+                items.append(BillLineItem(
+                    item_name=item_name,
+                    item_quantity=float(qty),
+                    item_rate=float(round(rate, 2)),
+                    item_amount=float(round(amount, 2)),
+                    confidence=min(1.0, max(0.0, confidence)),
+                    source_row=row_text,
+                ))
         else:
+            # Fallback: simple parsing without columns
             numeric_idxs = [i for i, t in enumerate(tokens) if is_numeric_token(t)]
             if not numeric_idxs:
                 continue
+            
             last = numeric_idxs[-1]
-            amt = normalize_num_str(tokens[last])
-            if amt is None:
+            amount = normalize_num_str(tokens[last], allow_zero=False)
+            if amount is None:
                 continue
+            
             name = " ".join(tokens[:last]).strip()
-            if not name:
-                continue
-            rate = None; qty = None
-
-            right_nums = []
-            for i in numeric_idxs:
-                v = normalize_num_str(tokens[i])
-                if v is not None:
-                    right_nums.append(float(v))
-            right_nums = sorted(list({int(x) if float(x).is_integer() else x for x in right_nums}), reverse=True)
-
-            if len(right_nums) >= 2:
-                cand = right_nums[1]
-                if float(cand) > 1 and float(cand) < float(amt):
-                    ratio = float(amt) / float(cand) if cand else None
-                    if ratio:
-                        r = round(ratio)
-                        if 1 <= r <= 200 and abs(ratio - r) <= max(0.03 * r, 0.15) and r <= 100:
-                            rate = float(cand)
-                            qty = float(r)
-            if rate is None and right_nums:
-                for cand in right_nums:
-                    if cand <= 1.0 or cand >= float(amt):
-                        continue
-                    ratio = float(amt) / float(cand)
-                    r = round(ratio)
-                    if 1 <= r <= 100 and abs(ratio - r) <= max(0.03 * r, 0.15):
-                        rate = float(cand)
-                        qty = float(r)
-                        break
-
-            if qty is None:
-                qty = 1.0
-            if rate is None:
-                rate = 0.0
-
-            parsed_items.append({
-                "item_name": clean_name_text(name),
-                "item_amount": float(round(amt, 2)),
-                "item_rate": float(round(rate, 2)),
-                "item_quantity": float(qty),
-            })
-    return parsed_items
-
-def dedupe_items(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    seen = set()
-    out = []
-    for it in items:
-        nm = re.sub(r"\s+", " ", (it.get("item_name","") or "").lower()).strip()
-        key = (nm[:120], round(float(it.get("item_amount", 0) or 0), 2))
-        if key in seen:
-            continue
-        seen.add(key)
-        out.append(it)
-    return out
-
-def looks_like_header_text(txt: str, top_of_page: bool = False) -> bool:
-    if not txt:
-        return False
-    t = re.sub(r"\s+", " ", txt.strip().lower())
-    if any(h == t for h in HEADER_PHRASES):
-        return True
-    hits = sum(1 for k in HEADER_KEYWORDS if k in t)
-    if hits >= 2:
-        return True
-    tokens = re.split(r"[\s\|,/:]+", t)
-    key_hit_count = sum(1 for tok in tokens if tok in HEADER_KEYWORDS)
-    if key_hit_count >= 3:
-        return True
-    if top_of_page and len(tokens) <= 10 and key_hit_count >= 2:
-        return True
-    if ("rate" in t or "net" in t) and "amt" in t and not any(ch.isdigit() for ch in t):
-        return True
-    if t.startswith("description") or t.startswith("qty") or t.startswith("qty /"):
-        return True
-    return False
-
-def final_item_filter(item: Dict[str, Any], known_page_headers: List[str] = []) -> bool:
-    name = (item.get("item_name") or "").strip()
-    if not name:
-        return False
-    ln = name.lower()
-    for h in known_page_headers:
-        if h and h.strip() and h.strip().lower() in ln:
-            return False
-    if FOOTER_KEYWORDS.search(ln):
-        return False
-    amt = float(item.get("item_amount", 0) or 0)
-    if amt <= 0:
-        return False
-    # sanity: weird giant amounts are likely OCR garbage
-    if amt > 10_000_000:
-        return False
-    rate = float(item.get("item_rate", 0) or 0)
-    if rate and rate > amt * 20 and amt < 10000:
-        return False
-    return True
+            name = clean_item_name(name) if name else "UNKNOWN"
+            
+            confidence = np.mean([c.get("conf", 0.85) for c in row]) if row else 0.85
+            items.append(BillLineItem(
+                item_name=name,
+                item_quantity=1.0,
+                item_rate=0.0,
+                item_amount=float(round(amount, 2)),
+                confidence=min(1.0, max(0.0, confidence)),
+                source_row=row_text,
+            ))
+    
+    return items
 
 # -------------------------------------------------------------------------
-# Gemini refinement (deterministic, optional)
+# Accuracy Validation
 # -------------------------------------------------------------------------
-def refine_with_gemini(page_items: List[Dict[str, Any]], page_text: str = "") -> Tuple[List[Dict[str, Any]], Dict[str,int]]:
-    zero_usage = {"total_tokens":0, "input_tokens":0, "output_tokens":0}
-    if not GEMINI_API_KEY or genai is None:
-        return page_items, zero_usage
-    try:
-        safe_text = sanitize_ocr_text(page_text)[:3000]
-        system_prompt = (
-            "You are a strict bill-extraction cleaner. Return ONLY a JSON array (no explanation, no backticks). "
-            "Each entry must be an object with keys: item_name (string), item_amount (float), item_rate (float), item_quantity (float). "
-            "Do NOT include subtotal or total lines as items. Do not invent items; only clean/fix/normalize the given items."
-        )
-        user_prompt = f"page_text='''{safe_text}'''\nitems={json.dumps(page_items, ensure_ascii=False)}\nReturn only the cleaned JSON array."
-        model = genai.GenerativeModel(GEMINI_MODEL_NAME)
-        response = model.generate_content(
-            [
-                {"role":"system","parts":[system_prompt]},
-                {"role":"user","parts":[user_prompt]},
-            ],
-            temperature=0.0,
-            max_output_tokens=1000,
-        )
-        raw = response.text.strip()
-        if raw.startswith("```"):
-            raw = re.sub(r"^```[a-zA-Z]*", "", raw)
-            raw = re.sub(r"```$", "", raw).strip()
-        parsed = json.loads(raw)
-        out = []
-        for obj in parsed:
-            try:
-                out.append({
-                    "item_name": str(obj.get("item_name","")).strip(),
-                    "item_amount": float(obj.get("item_amount",0.0)),
-                    "item_rate": float(obj.get("item_rate",0.0) or 0.0),
-                    "item_quantity": float(obj.get("item_quantity",1.0) or 1.0),
-                })
-            except Exception:
-                continue
-        return out, zero_usage
-    except Exception as e:
-        logger.warning("Gemini refine failed: %s", e)
-        return page_items, zero_usage
-
-# -------------------------------------------------------------------------
-# OCR engine implementations
-# -------------------------------------------------------------------------
-def ocr_with_textract(file_bytes: bytes) -> List[Dict[str, Any]]:
-    """
-    Use Amazon Textract AnalyzeExpense on each page image. Returns list of pages:
-      [{"page_no": "1", "page_type": "...", "bill_items": [...]}]
-    Note: Textract AnalyzeExpense returns structured expense/line-item data; we map it to our output.
-    """
-    pages_out = []
-    client = textract_client()
-
-    # Convert bytes to images and call AnalyzeExpense for each page (synchronous).
-    try:
-        images = convert_from_bytes(file_bytes)
-    except Exception as e:
-        logger.warning("Textract fallback: PDF->image conversion failed: %s", e)
-        return []
-
-    for idx, pil_img in enumerate(images, start=1):
-        bio = BytesIO()
-        pil_img.save(bio, format="JPEG", quality=90)
-        img_bytes = bio.getvalue()
-        try:
-            resp = client.analyze_expense(Document={'Bytes': img_bytes})
-        except (BotoCoreError, ClientError) as e:
-            logger.exception("Textract analyze_expense failed: %s", e)
-            pages_out.append({"page_no": str(idx), "page_type": "Bill Detail", "bill_items": []})
-            continue
-        # Parse Textract response
-        items = []
-        line_item_groups = resp.get("ExpenseDocuments", [])
-        if line_item_groups:
-            for doc in line_item_groups:
-                groups = doc.get("LineItemGroups", [])
-                for g in groups:
-                    for li in g.get("LineItems", []):
-                        # Each line item has LineItemExpenseFields list
-                        name_parts = []
-                        amount = None
-                        rate = None
-                        qty = None
-                        for f in li.get("LineItemExpenseFields", []):
-                            tname = f.get("Type", {}).get("Text", "") or ""
-                            v = f.get("ValueDetection", {}).get("Text", "") or ""
-                            txt_l = tname.lower()
-                            if txt_l in ("item", "description", "item description", "service"):
-                                name_parts.append(v)
-                            elif txt_l in ("amount", "price", "total"):
-                                maybe = normalize_num_str(v)
-                                if maybe is not None:
-                                    amount = maybe
-                            elif txt_l in ("quantity", "qty"):
-                                maybe = normalize_num_str(v)
-                                if maybe is not None:
-                                    qty = maybe
-                            elif txt_l in ("rate", "unit price", "price per unit"):
-                                maybe = normalize_num_str(v)
-                                if maybe is not None:
-                                    rate = maybe
-                            else:
-                                # Heuristic: if value looks numeric and field name is empty, try assign
-                                if is_numeric_token(v) and amount is None:
-                                    maybe = normalize_num_str(v)
-                                    if maybe is not None:
-                                        amount = maybe
-                                elif v and not is_numeric_token(v):
-                                    name_parts.append(v)
-                        name = " ".join(name_parts).strip() or "UNKNOWN"
-                        # Post-process amount/rate/qty
-                        if amount is None:
-                            # try to find from summary fields
-                            pass
-                        if qty is None and rate is not None and amount is not None and rate != 0:
-                            try:
-                                qty = round(amount / rate, 2)
-                            except Exception:
-                                qty = 1.0
-                        if qty is None:
-                            qty = 1.0
-                        if rate is None and qty and qty != 0 and amount is not None:
-                            try:
-                                rate = round(amount / qty, 2)
-                            except Exception:
-                                rate = 0.0
-                        if amount is None:
-                            amount = 0.0
-                        items.append({
-                            "item_name": clean_name_text(name),
-                            "item_amount": float(round(amount, 2)),
-                            "item_rate": float(round(rate or 0.0, 2)),
-                            "item_quantity": float(qty or 1.0),
-                        })
-        # Fallback: if Textract returned no structured line items, attempt to extract lines from Blocks
-        if not items:
-            # try to extract lines from DocumentMetadata / Blocks
-            blocks = resp.get("Blocks", [])
-            lines = []
-            for b in blocks:
-                if b.get("BlockType") == "LINE":
-                    lines.append(b.get("Text", ""))
-            # naive fallback: group lines that contain numbers
-            for ln in lines:
-                tokens = ln.split()
-                numbers = [t for t in tokens if is_numeric_token(t)]
-                if numbers:
-                    name = " ".join([t for t in tokens if not is_numeric_token(t)])
-                    amount = None
-                    for t in reversed(tokens):
-                        if is_numeric_token(t):
-                            v = normalize_num_str(t)
-                            if v is not None:
-                                amount = v
-                                break
-                    if amount:
-                        items.append({
-                            "item_name": clean_name_text(name or "UNKNOWN"),
-                            "item_amount": float(round(amount, 2)),
-                            "item_rate": 0.0,
-                            "item_quantity": 1.0,
-                        })
-        # Filter & dedupe
-        items = [it for it in items if final_item_filter(it, [])]
-        items = dedupe_items(items)
-        page_type = "Bill Detail"
-        items_text = " ".join([it["item_name"] for it in items]).lower()
-        if "pharmacy" in items_text or "tablet" in items_text or "medicine" in items_text:
-            page_type = "Pharmacy"
-        pages_out.append({"page_no": str(idx), "page_type": page_type, "bill_items": items})
-    return pages_out
-
-def ocr_with_google_vision(file_bytes: bytes) -> List[Dict[str,Any]]:
+def validate_totals(
+    line_items: List[BillLineItem],
+    bill_totals: BillTotal,
+    tolerance_pct: float = 2.0
+) -> Tuple[float, str]:
     """
-    Google Vision Document OCR pipeline. Returns parsed pages (same format).
+    Validate extracted items sum vs bill total.
+    Returns: (accuracy_score 0-100, validation_msg)
     """
-    client = vision_client()
-    pages_out = []
-    try:
-        images = convert_from_bytes(file_bytes)
-    except Exception as e:
-        logger.warning("Vision pipeline: PDF->image conversion failed: %s", e)
-        return []
-    for idx, pil_img in enumerate(images, start=1):
-        bio = BytesIO()
-        pil_img.save(bio, format="JPEG", quality=90)
-        content = bio.getvalue()
-        image = vision.Image(content=content)
-        resp = client.document_text_detection(image=image)
-        text = resp.full_text_annotation.text if resp.full_text_annotation else ""
-        # Build pseudo-cells from words using bounding boxes if available
-        cells = []
-        for page in (resp.full_text_annotation.pages or []):
-            for block in page.blocks:
-                for para in block.paragraphs:
-                    for word in para.words:
-                        word_text = "".join([sym.text for sym in word.symbols])
-                        bbox = word.bounding_box
-                        # compute approximate left/top/width/height
-                        xs = [v.x for v in bbox.vertices]
-                        ys = [v.y for v in bbox.vertices]
-                        left = int(min(xs)) if xs else 0
-                        top = int(min(ys)) if ys else 0
-                        width = int(max(xs)-min(xs)) if xs else 0
-                        height = int(max(ys)-min(ys)) if ys else 0
-                        center_x = left + width/2.0
-                        center_y = top + height/2.0
-                        cells.append({"text": word_text, "conf": -1.0, "left": left, "top": top, "width": width, "height": height, "center_x": center_x, "center_y": center_y})
-        # row grouping + parse using shared functions
-        rows = group_cells_into_rows(cells, y_tolerance=14)
-        parsed_items = parse_rows_with_columns(rows, cells)
-        cleaned = [p for p in parsed_items if final_item_filter(p, [])]
-        cleaned = dedupe_items(cleaned)
-        page_type = "Bill Detail"
-        page_txt = text.lower()
-        if any(x in page_txt for x in ["pharmacy", "medicine", "tablet"]):
-            page_type = "Pharmacy"
-        pages_out.append({"page_no": str(idx), "page_type": page_type, "bill_items": cleaned})
-    return pages_out
+    if not line_items:
+        return 0.0, "No line items extracted"
+    
+    items_sum = sum(item.item_amount for item in line_items)
+    
+    # If we detected a final total, compare
+    if bill_totals.final_total_amount is not None:
+        final_total = bill_totals.final_total_amount
+        diff = abs(items_sum - final_total)
+        diff_pct = (diff / final_total * 100) if final_total != 0 else 0.0
+        
+        if diff_pct <= tolerance_pct:
+            score = 100.0
+            msg = f"✓ Extracted total ({items_sum:.2f}) matches bill total ({final_total:.2f})"
+        else:
+            # Scale score based on how close
+            score = max(0.0, 100.0 - (diff_pct * 5))
+            msg = f"⚠ Mismatch: items_sum={items_sum:.2f}, bill_total={final_total:.2f}, diff={diff_pct:.1f}%"
+        
+        return score, msg
+    
+    return 85.0, f"No bill total detected; items_sum={items_sum:.2f}"
 
-def ocr_with_tesseract(file_bytes: bytes) -> List[Dict[str,Any]]:
-    """Tesseract pipeline using your preprocessing + TSV + parsing functions."""
+# -------------------------------------------------------------------------
+# Main OCR Pipelines (Tesseract)
+# -------------------------------------------------------------------------
+def ocr_with_tesseract(file_bytes: bytes) -> List[ExtractedPage]:
+    """Enhanced Tesseract pipeline"""
     pages_out = []
+    
     try:
         images = convert_from_bytes(file_bytes)
-    except Exception as e:
-        # maybe it's a single image format (jpg/png)
+    except Exception:
         try:
             im = Image.open(BytesIO(file_bytes))
             images = [im]
-        except Exception:
-            logger.exception("Tesseract pipeline can't open file: %s", e)
+        except Exception as e:
+            logger.exception("Tesseract: file open failed: %s", e)
             return []
+    
     for idx, pil_img in enumerate(images, start=1):
         try:
+            # Preprocess & extract
             proc = preprocess_image_for_tesseract(pil_img)
             cells = image_to_tsv_cells(proc)
             rows = group_cells_into_rows(cells, y_tolerance=12)
-            rows_texts = [" ".join([c["text"] for c in r]).strip() for r in rows]
-            # header prefilter
-            rows_filtered = []
-            for i, (r, rt) in enumerate(zip(rows, rows_texts)):
-                top_flag = (i < 6)
-                rt_norm = sanitize_ocr_text(rt).lower()
-                if looks_like_header_text(rt_norm, top_of_page=top_flag):
-                    continue
-                if any(h in rt_norm for h in HEADER_PHRASES):
+            
+            # Get page text
+            page_text = " ".join([" ".join([c["text"] for c in r]) for r in rows])
+            
+            # Detect totals early
+            subtotal, tax, discount, final_total = detect_totals_in_rows(rows)
+            
+            # Parse line items
+            items = parse_rows_with_columns(rows, cells, page_text)
+            
+            # Deduplicate
+            items = dedupe_items_advanced(items)
+            
+            # Filter (exclude totals/subtotals)
+            filtered_items = []
+            for item in items:
+                name_lower = item.item_name.lower()
+                
+                # Skip if name matches total keywords
+                if TOTAL_KEYWORDS.search(name_lower) or SUBTOTAL_KEYWORDS.search(name_lower):
                     continue
-                rows_filtered.append(r)
-            rows = rows_filtered
-            parsed_items = parse_rows_with_columns(rows, cells)
-            refined_items, _ = refine_with_gemini(parsed_items, sanitize_ocr_text(" ".join(rows_texts)))
-            cleaned = [p for p in refined_items if final_item_filter(p, [])]
-            cleaned = dedupe_items(cleaned)
-            page_type = "Bill Detail"
-            page_txt = " ".join(rows_texts).lower()
-            if any(x in page_txt for x in ["pharmacy", "medicine", "tablet"]):
-                page_type = "Pharmacy"
-            pages_out.append({"page_no": str(idx), "page_type": page_type, "bill_items": cleaned})
+                
+                if item.item_amount > 0:
+                    filtered_items.append(item)
+            
+            # Create bill totals object
+            bill_totals = BillTotal(
+                subtotal_amount=subtotal,
+                tax_amount=tax,
+                discount_amount=discount,
+                final_total_amount=final_total,
+            )
+            
+            # Validate
+            accuracy, val_msg = validate_totals(filtered_items, bill_totals)
+            logger.info(f"Page {idx}: {val_msg}")
+            
+            page_conf = np.mean([item.confidence for item in filtered_items]) if filtered_items else 0.8
+            
+            pages_out.append(ExtractedPage(
+                page_no=idx,
+                page_type="Bill Detail",
+                line_items=filtered_items,
+                bill_totals=bill_totals,
+                page_confidence=page_conf,
+            ))
+        
         except Exception as e:
-            logger.exception("Tesseract parse page failed: %s", e)
-            pages_out.append({"page_no": str(idx), "page_type": "Bill Detail", "bill_items": []})
+            logger.exception(f"Tesseract page {idx} failed: %s", e)
+            pages_out.append(ExtractedPage(
+                page_no=idx,
+                page_type="Bill Detail",
+                line_items=[],
+                bill_totals=BillTotal(),
+                page_confidence=0.0,
+            ))
+    
     return pages_out
 
 # -------------------------------------------------------------------------
-# Main endpoint
+# FastAPI App
 # -------------------------------------------------------------------------
-@app.post("/extract-bill-data")
+app = FastAPI(title="Enhanced Bill Extractor (Datathon v2)")
+
+class BillRequest(BaseModel):
+    document: str  # file://path or http(s) URL
+
+class BillResponse(BaseModel):
+    is_success: bool
+    error: Optional[str] = None
+    data: Dict[str, Any]
+    accuracy_score: float  # 0-100
+    validation_message: str
+    token_usage: Dict[str, int]
+
+@app.post("/extract-bill-data", response_model=BillResponse)
 async def extract_bill_data(payload: BillRequest):
+    """Main extraction endpoint"""
     doc_url = payload.document
     file_bytes = None
-
-    # local file support
+    
+    # Load file
     if doc_url.startswith("file://"):
         local_path = doc_url.replace("file://", "")
         try:
             with open(local_path, "rb") as f:
                 file_bytes = f.read()
         except Exception as e:
-            return {"is_success": False, "error": f"Local file read error: {e}",
-                    "data": {"pagewise_line_items": [], "total_item_count": 0}, "token_usage": {"total_tokens":0,"input_tokens":0,"output_tokens":0}}
+            return BillResponse(
+                is_success=False,
+                error=f"Local file read failed: {e}",
+                data={"pagewise_line_items": [], "total_item_count": 0},
+                accuracy_score=0.0,
+                validation_message="File load failed",
+                token_usage={"total_tokens": 0, "input_tokens": 0, "output_tokens": 0},
+            )
     else:
         try:
             headers = {"User-Agent": "Mozilla/5.0"}
             resp = requests.get(doc_url, headers=headers, timeout=30)
             if resp.status_code != 200:
-                return {"is_success": False, "error": f"Download failed status={resp.status_code}",
-                        "data": {"pagewise_line_items": [], "total_item_count": 0}, "token_usage": {"total_tokens":0,"input_tokens":0,"output_tokens":0}}
+                return BillResponse(
+                    is_success=False,
+                    error=f"Download failed (status={resp.status_code})",
+                    data={"pagewise_line_items": [], "total_item_count": 0},
+                    accuracy_score=0.0,
+                    validation_message="HTTP error",
+                    token_usage={"total_tokens": 0, "input_tokens": 0, "output_tokens": 0},
+                )
             file_bytes = resp.content
         except Exception as e:
-            return {"is_success": False, "error": f"HTTP error: {e}",
-                    "data": {"pagewise_line_items": [], "total_item_count": 0}, "token_usage": {"total_tokens":0,"input_tokens":0,"output_tokens":0}}
-
+            return BillResponse(
+                is_success=False,
+                error=f"HTTP error: {e}",
+                data={"pagewise_line_items": [], "total_item_count": 0},
+                accuracy_score=0.0,
+                validation_message="Network error",
+                token_usage={"total_tokens": 0, "input_tokens": 0, "output_tokens": 0},
+            )
+    
     if not file_bytes:
-        return {"is_success": False, "error": "No file bytes found", "data": {"pagewise_line_items": [], "total_item_count": 0}, "token_usage": {"total_tokens":0,"input_tokens":0,"output_tokens":0}}
-
-    pages = []
-    token_usage = {"total_tokens":0,"input_tokens":0,"output_tokens":0}
-    engine = OCR_ENGINE
-    logger.info("Using OCR engine: %s", engine)
-
+        return BillResponse(
+            is_success=False,
+            error="No file bytes",
+            data={"pagewise_line_items": [], "total_item_count": 0},
+            accuracy_score=0.0,
+            validation_message="Empty file",
+            token_usage={"total_tokens": 0, "input_tokens": 0, "output_tokens": 0},
+        )
+    
+    # Extract
+    logger.info(f"Processing with engine: {OCR_ENGINE}")
     try:
-        if engine == "textract":
-            pages = ocr_with_textract(file_bytes)
-        elif engine == "vision":
-            pages = ocr_with_google_vision(file_bytes)
-        else:
+        if OCR_ENGINE == "tesseract":
             pages = ocr_with_tesseract(file_bytes)
-    except Exception as e:
-        logger.exception("OCR engine failed: %s", e)
-        # fallback to tesseract pipeline
-        try:
-            pages = ocr_with_tesseract(file_bytes)
-        except Exception as e:
-            logger.exception("Tesseract fallback also failed: %s", e)
-            pages = []
-
-    total_item_count = sum(len(p.get("bill_items", [])) for p in pages)
-    if not GEMINI_API_KEY or genai is None:
-        token_usage["warning_no_gemini"] = 1
-
-    return {"is_success": True, "token_usage": token_usage, "data": {"pagewise_line_items": pages, "total_item_count": total_item_count}}
-
-# -------------------------------------------------------------------------
-# Debug endpoint to return tsv cell info for inspection
-# -------------------------------------------------------------------------
-@app.post("/debug-tsv")
-async def debug_tsv(payload: BillRequest):
-    doc_url = payload.document
-    try:
-        if doc_url.startswith("file://"):
-            local_path = doc_url.replace("file://", "")
-            with open(local_path, "rb") as f:
-                file_bytes = f.read()
         else:
-            resp = requests.get(doc_url, timeout=20)
-            resp.raise_for_status()
-            file_bytes = resp.content
+            # Fallback to tesseract
+            pages = ocr_with_tesseract(file_bytes)
     except Exception as e:
-        return {"error": f"Download failed: {e}"}
-    try:
-        imgs = convert_from_bytes(file_bytes)
-        img = imgs[0]
-    except Exception:
-        try:
-            img = Image.open(BytesIO(file_bytes)).convert("RGB")
-        except Exception as e:
-            return {"error": f"Image conversion failed: {e}"}
-    proc = preprocess_image_for_tesseract(img)
-    cells = image_to_tsv_cells(proc)
-    return {"cells": cells}
+        logger.exception("OCR failed: %s", e)
+        pages = []
+    
+    # Prepare response
+    total_items = sum(len(p.line_items) for p in pages)
+    pages_dict = [p.to_dict() for p in pages]
+    
+    # Calculate overall accuracy
+    all_items = [item for p in pages for item in p.line_items]
+    all_totals = BillTotal(
+        subtotal_amount=sum(p.bill_totals.subtotal_amount or 0 for p in pages) or None,
+        tax_amount=sum(p.bill_totals.tax_amount or 0 for p in pages) or None,
+        discount_amount=sum(p.bill_totals.discount_amount or 0 for p in pages) or None,
+        final_total_amount=sum(p.bill_totals.final_total_amount or 0 for p in pages) or None,
+    )
+    
+    overall_acc, msg = validate_totals(all_items, all_totals)
+    
+    return BillResponse(
+        is_success=True,
+        data={
+            "pagewise_line_items": pages_dict,
+            "total_item_count": total_items,
+        },
+        accuracy_score=overall_acc,
+        validation_message=msg,
+        token_usage={"total_tokens": 0, "input_tokens": 0, "output_tokens": 0},
+    )
 
 @app.get("/")
-def health_check():
-    msg = f"Bill extraction API live. OCR_ENGINE={OCR_ENGINE}"
-    if not GEMINI_API_KEY or genai is None:
-        msg += " (Gemini not configured — LLM refinement skipped.)"
-    return {"status": "ok", "message": msg, "hint": "POST /extract-bill-data with {'document':'<url or file://path>'}"}
+def health():
+    return {
+        "status": "ok",
+        "engine": OCR_ENGINE,
+        "message": "Enhanced Bill Extractor (Datathon v2 - High Accuracy Mode)",
+        "hint": "POST /extract-bill-data with {'document': '<url or file://path>'}",
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8080)