Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,702 @@
+import os
+import io
+import re
+import tempfile
+import pandas as pd
+import fitz  # PyMuPDF
+import torch
+import openpyxl
+from PIL import Image, ImageDraw
+from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+import gradio as gr
+
+# Auto-detect device and precision
+device = "cuda" if torch.cuda.is_available() else "cpu"
+if device == "cuda":
+    dtype = torch.bfloat16
+else:
+    dtype = torch.float32
+
+print(f"Using device: {device}, dtype: {dtype}")
+
+# Global model caches
+layout_processor = None
+layout_model = None
+tatr_processor = None
+tatr_model = None
+glm_processor = None
+glm_model = None
+
+def load_layout_model():
+    global layout_processor, layout_model
+    if layout_model is None:
+        print("Loading PP-DocLayoutV3...")
+        from transformers import AutoImageProcessor, AutoModelForObjectDetection
+        model_path = "PaddlePaddle/PP-DocLayoutV3_safetensors"
+        layout_processor = AutoImageProcessor.from_pretrained(model_path, trust_remote_code=True)
+        layout_model = AutoModelForObjectDetection.from_pretrained(
+            model_path, 
+            trust_remote_code=True
+        ).to(device)
+    return layout_processor, layout_model
+
+def load_tatr_model():
+    global tatr_processor, tatr_model
+    if tatr_model is None:
+        print("Loading Table Transformer (TATR) Structure...")
+        from transformers import DetrImageProcessor, TableTransformerForObjectDetection
+        model_path = "microsoft/table-transformer-structure-recognition"
+        tatr_processor = DetrImageProcessor.from_pretrained(model_path)
+        tatr_model = TableTransformerForObjectDetection.from_pretrained(model_path).to(device)
+    return tatr_processor, tatr_model
+
+def load_glm_model():
+    global glm_processor, glm_model
+    if glm_model is None:
+        print("Loading GLM-OCR...")
+        from transformers import AutoProcessor
+        try:
+            from transformers import GlmOcrForConditionalGeneration
+        except ImportError:
+            from transformers import AutoModelForCausalLM as GlmOcrForConditionalGeneration
+            
+        model_path = "zai-org/GLM-OCR"
+        glm_processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
+        
+        # Load model with correct dtype and device map
+        if device == "cuda":
+            glm_model = GlmOcrForConditionalGeneration.from_pretrained(
+                model_path,
+                trust_remote_code=True,
+                torch_dtype=dtype,
+                device_map="auto"
+            )
+        else:
+            glm_model = GlmOcrForConditionalGeneration.from_pretrained(
+                model_path,
+                trust_remote_code=True,
+                torch_dtype=dtype
+            ).to(device)
+            
+    return glm_processor, glm_model
+
+# -------------------------------------------------------------
+# Core Pipeline Functions
+# -------------------------------------------------------------
+
+def convert_pdf_to_images(pdf_path, dpi=300):
+    """Convert PDF pages to PIL Images at 300 DPI."""
+    doc = fitz.open(pdf_path)
+    images = []
+    for page_num in range(len(doc)):
+        page = doc.load_page(page_num)
+        zoom = dpi / 72.0
+        matrix = fitz.Matrix(zoom, zoom)
+        pix = page.get_pixmap(matrix=matrix)
+        img_data = pix.tobytes("png")
+        img = Image.open(io.BytesIO(img_data)).convert("RGB")
+        images.append(img)
+    return images
+
+def detect_tables(image, confidence_threshold=0.4):
+    """Detect tables using PP-DocLayoutV3."""
+    processor, model = load_layout_model()
+    inputs = processor(images=image, return_tensors="pt").to(device)
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        
+    target_sizes = [image.size[::-1]]
+    results = processor.post_process_object_detection(
+        outputs, 
+        target_sizes=target_sizes, 
+        threshold=confidence_threshold
+    )[0]
+    
+    id2label = model.config.id2label
+    table_label_ids = [k for k, v in id2label.items() if "table" in v.lower()]
+    
+    tables = []
+    for score, label_id, box in zip(results["scores"], results["labels"], results["boxes"]):
+        if label_id.item() in table_label_ids:
+            box = [int(coord) for coord in box.tolist()] # [xmin, ymin, xmax, ymax]
+            tables.append({
+                "box": box,
+                "score": score.item()
+            })
+            
+    # Sort tables top to bottom by ymin
+    tables = sorted(tables, key=lambda x: x["box"][1])
+    return tables
+
+def extract_table_structure(table_img, confidence_threshold=0.8):
+    """Extract rows, columns, and spanning cells using Table Transformer."""
+    processor, model = load_tatr_model()
+    inputs = processor(images=table_img, return_tensors="pt").to(device)
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+        
+    target_sizes = [table_img.size[::-1]]
+    results = processor.post_process_object_detection(
+        outputs, 
+        target_sizes=target_sizes, 
+        threshold=confidence_threshold
+    )[0]
+    
+    rows = []
+    columns = []
+    spanning_cells = []
+    
+    id2label = model.config.id2label
+    for score, label_id, box in zip(results["scores"], results["labels"], results["boxes"]):
+        label = id2label[label_id.item()]
+        box = [int(coord) for coord in box.tolist()]
+        if label == "table row":
+            rows.append(box)
+        elif label == "table column":
+            columns.append(box)
+        elif label == "table spanning cell":
+            spanning_cells.append(box)
+            
+    # Sort rows by ymin (top to bottom)
+    rows = sorted(rows, key=lambda x: x[1])
+    # Sort columns by xmin (left to right)
+    columns = sorted(columns, key=lambda x: x[0])
+    
+    # Fallback to single cell if structure detection fails
+    if not rows:
+        rows = [[0, 0, table_img.width, table_img.height]]
+    if not columns:
+        columns = [[0, 0, table_img.width, table_img.height]]
+        
+    return rows, columns, spanning_cells
+
+def run_glm_ocr(image, prompt="Text Recognition:"):
+    """Run GLM-OCR on an image crop."""
+    processor, model = load_glm_model()
+    
+    temp_dir = tempfile.gettempdir()
+    temp_file_path = os.path.join(temp_dir, f"temp_cell_{os.getpid()}_{id(image)}.png")
+    image.save(temp_file_path)
+    
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "url": temp_file_path},
+                {"type": "text", "text": prompt},
+            ],
+        }
+    ]
+    
+    try:
+        if hasattr(processor, "apply_chat_template"):
+            inputs = processor.apply_chat_template(
+                messages, 
+                tokenize=True, 
+                add_generation_prompt=True, 
+                return_dict=True, 
+                return_tensors="pt"
+            ).to(device)
+        else:
+            inputs = processor(images=image, text=prompt, return_tensors="pt").to(device)
+            
+        if "pixel_values" in inputs:
+            inputs["pixel_values"] = inputs["pixel_values"].to(dtype)
+            
+        with torch.no_grad():
+            output = model.generate(**inputs, max_new_tokens=512)
+            
+        text = processor.decode(output[0], skip_special_tokens=True)
+        
+        # Clean up prompts or prefixes from visual outputs
+        if prompt in text:
+            text = text.split(prompt)[-1]
+        elif "assistant" in text.lower():
+            text = text.split("assistant")[-1]
+            
+        return text.strip()
+    except Exception as e:
+        print(f"GLM-OCR error: {e}")
+        return ""
+    finally:
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+# -------------------------------------------------------------
+# Table Reconstruction & Layout Helpers
+# -------------------------------------------------------------
+
+def get_intersection_area(box1, box2):
+    x_left = max(box1[0], box2[0])
+    y_top = max(box1[1], box2[1])
+    x_right = min(box1[2], box2[2])
+    y_bottom = min(box1[3], box2[3])
+    
+    if x_right < x_left or y_bottom < y_top:
+        return 0.0
+    return (x_right - x_left) * (y_bottom - y_top)
+
+def get_area(box):
+    return (box[2] - box[0]) * (box[3] - box[1])
+
+def build_grid_and_ocr(table_img, rows, columns, spanning_cells, progress_callback=None):
+    """Run OCR on cells and build cell-to-span mappings for openpyxl merges."""
+    num_rows = len(rows)
+    num_cols = len(columns)
+    
+    data = [["" for _ in range(num_cols)] for _ in range(num_rows)]
+    grid_spanning_map = {}
+    
+    # 1. Map spanning cells to grid cells
+    for s_idx, s_box in enumerate(spanning_cells):
+        covered_cells = []
+        for r_idx, row in enumerate(rows):
+            for c_idx, col in enumerate(columns):
+                g_box = [col[0], row[1], col[2], row[3]]
+                g_area = get_area(g_box)
+                if g_area <= 0:
+                    continue
+                inter = get_intersection_area(g_box, s_box)
+                if inter / g_area > 0.5:
+                    covered_cells.append((r_idx, c_idx))
+        if covered_cells:
+            rs = [c[0] for c in covered_cells]
+            cs = [c[1] for c in covered_cells]
+            r_min, r_max = min(rs), max(rs)
+            c_min, c_max = min(cs), max(cs)
+            for r in range(r_min, r_max + 1):
+                for c in range(c_min, c_max + 1):
+                    grid_spanning_map[(r, c)] = {
+                        "span_id": s_idx,
+                        "r_min": r_min,
+                        "r_max": r_max,
+                        "c_min": c_min,
+                        "c_max": c_max,
+                        "box": s_box
+                    }
+
+    # 2. Iterate grid and perform OCR
+    total_cells = num_rows * num_cols
+    cell_counter = 0
+    
+    for r_idx, row in enumerate(rows):
+        r_ymin, r_ymax = row[1], row[3]
+        for c_idx, col in enumerate(columns):
+            c_xmin, c_xmax = col[0], col[2]
+            cell_counter += 1
+            
+            if progress_callback:
+                progress_callback(cell_counter / total_cells, f"OCR on Cell {cell_counter}/{total_cells} (Row {r_idx+1}, Col {c_idx+1})")
+                
+            # If part of a spanning cell, check if we are the top-left cell
+            if (r_idx, c_idx) in grid_spanning_map:
+                span = grid_spanning_map[(r_idx, c_idx)]
+                if r_idx == span["r_min"] and c_idx == span["c_min"]:
+                    # Crop spanning box instead of grid cell
+                    s_box = span["box"]
+                    xmin = max(0, int(s_box[0]))
+                    ymin = max(0, int(s_box[1]))
+                    xmax = min(table_img.width, int(s_box[2]))
+                    ymax = min(table_img.height, int(s_box[3]))
+                    
+                    cell_crop = table_img.crop((xmin, ymin, xmax, ymax))
+                    cell_text = run_glm_ocr(cell_crop, prompt="Text Recognition:")
+                    data[r_idx][c_idx] = cell_text
+                else:
+                    # Skip OCR for other merged cells (Excel merge will use top-left cell value)
+                    data[r_idx][c_idx] = ""
+            else:
+                # Ordinary cell crop
+                xmin = max(0, int(c_xmin))
+                ymin = max(0, int(r_ymin))
+                xmax = min(table_img.width, int(c_xmax))
+                ymax = min(table_img.height, int(r_ymax))
+                
+                if xmax > xmin and ymax > ymin:
+                    cell_crop = table_img.crop((xmin, ymin, xmax, ymax))
+                    cell_text = run_glm_ocr(cell_crop, prompt="Text Recognition:")
+                    data[r_idx][c_idx] = cell_text
+                else:
+                    data[r_idx][c_idx] = ""
+                    
+    df = pd.DataFrame(data)
+    return df, grid_spanning_map
+
+def parse_markdown_table(md_text):
+    """Parse Markdown table outputted by GLM-OCR Table Recognition into DataFrame."""
+    lines = [line.strip() for line in md_text.split("\n") if line.strip()]
+    table_lines = []
+    in_table = False
+    
+    for line in lines:
+        if line.startswith("|"):
+            in_table = True
+            table_lines.append(line)
+        elif in_table:
+            break
+            
+    if not table_lines:
+        return pd.DataFrame([[md_text]])
+        
+    data = []
+    for line in table_lines:
+        parts = [p.strip() for p in line.split("|")]
+        if parts and parts[0] == "":
+            parts = parts[1:]
+        if parts and parts[-1] == "":
+            parts = parts[:-1]
+        data.append(parts)
+        
+    if not data:
+        return pd.DataFrame([[md_text]])
+        
+    # Check for header separator line
+    if len(data) > 1 and all(re.match(r"^[-:\s|]+$", cell) for cell in data[1]):
+        header = data[0]
+        rows = data[2:]
+    else:
+        header = None
+        rows = data
+        
+    if header:
+        # Check alignment length matching
+        if len(rows) > 0 and len(rows[0]) != len(header):
+            return pd.DataFrame(rows)
+        return pd.DataFrame(rows, columns=header)
+    else:
+        return pd.DataFrame(rows)
+
+# -------------------------------------------------------------
+# Excel Writing & Styling
+# -------------------------------------------------------------
+
+def generate_excel_workbook(sheets_data, output_path):
+    """Write parsed DataFrames with styling and merges to Excel."""
+    wb = openpyxl.Workbook()
+    wb.remove(wb.active) # Remove default sheet
+    
+    header_font = Font(name="Calibri", size=11, bold=True, color="FFFFFF")
+    header_fill = PatternFill(start_color="366092", end_color="366092", fill_type="solid") # Dark steel blue
+    thin_border = Border(
+        left=Side(style='thin', color='D9D9D9'),
+        right=Side(style='thin', color='D9D9D9'),
+        top=Side(style='thin', color='D9D9D9'),
+        bottom=Side(style='thin', color='D9D9D9')
+    )
+    
+    for sheet_name, table_dict in sheets_data.items():
+        df = table_dict["df"]
+        grid_spanning_map = table_dict.get("grid_spanning_map", {})
+        
+        ws = wb.create_sheet(title=sheet_name)
+        ws.views.sheetView[0].showGridLines = True
+        
+        # Write values
+        for r_idx in range(len(df)):
+            for c_idx in range(len(df.columns)):
+                val = df.iloc[r_idx, c_idx]
+                ws.cell(row=r_idx + 1, column=c_idx + 1, value=str(val))
+                
+        # Apply premium styling
+        num_rows, num_cols = df.shape
+        for r in range(1, num_rows + 1):
+            for c in range(1, num_cols + 1):
+                cell = ws.cell(row=r, column=c)
+                cell.border = thin_border
+                
+                # Check header styling (row 1)
+                if r == 1:
+                    cell.font = header_font
+                    cell.fill = header_fill
+                    cell.alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
+                else:
+                    cell.font = Font(name="Calibri", size=11)
+                    cell.alignment = Alignment(horizontal="left", vertical="center", wrap_text=True)
+                    
+        # Apply merged ranges
+        merged_ranges = set()
+        for (r, c), span in grid_spanning_map.items():
+            r_min, r_max = span["r_min"], span["r_max"]
+            c_min, c_max = span["c_min"], span["c_max"]
+            if r_max > r_min or c_max > c_min:
+                merged_ranges.add((r_min + 1, c_min + 1, r_max + 1, c_max + 1))
+                
+        for merge_range in merged_ranges:
+            ws.merge_cells(
+                start_row=merge_range[0],
+                start_column=merge_range[1],
+                end_row=merge_range[2],
+                end_column=merge_range[3]
+            )
+            # Center alignment on merged cells
+            top_left_cell = ws.cell(row=merge_range[0], column=merge_range[1])
+            top_left_cell.alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
+            
+        # Auto-adjust column widths
+        for col in ws.columns:
+            max_len = 0
+            col_letter = openpyxl.utils.get_column_letter(col[0].column)
+            for cell in col:
+                if cell.value:
+                    max_len = max(max_len, len(str(cell.value)))
+            ws.column_dimensions[col_letter].width = min(max(max_len + 3, 10), 55)
+            
+    wb.save(output_path)
+
+# -------------------------------------------------------------
+# Visual Drawing Helpers
+# -------------------------------------------------------------
+
+def draw_table_boxes(image, tables):
+    """Draw bounding boxes of detected tables on the page image."""
+    img_copy = image.copy()
+    draw = ImageDraw.Draw(img_copy)
+    for idx, t in enumerate(tables):
+        box = t["box"]
+        draw.rectangle(box, outline="#FF5722", width=5) # Orange box
+        # Draw table label index
+        draw.rectangle([box[0], box[1] - 30, box[0] + 120, box[1]], fill="#FF5722")
+        draw.text((box[0] + 10, box[1] - 25), f"Table {idx+1}", fill="white")
+    return img_copy
+
+def draw_structure_grid(table_img, rows, columns):
+    """Draw rows and columns grid overlay."""
+    img_copy = table_img.copy()
+    draw = ImageDraw.Draw(img_copy)
+    
+    # Draw horizontal red lines for rows
+    for idx, r in enumerate(rows):
+        draw.line((0, r[1], table_img.width, r[1]), fill="#E91E63", width=3) # Pink
+        draw.line((0, r[3], table_img.width, r[3]), fill="#E91E63", width=3)
+        draw.text((10, r[1] + 5), f"R{idx+1}", fill="#E91E63")
+        
+    # Draw vertical blue lines for columns
+    for idx, c in enumerate(columns):
+        draw.line((c[0], 0, c[0], table_img.height), fill="#2196F3", width=3) # Blue
+        draw.line((c[2], 0, c[2], table_img.height), fill="#2196F3", width=3)
+        draw.text((c[0] + 5, 10), f"C{idx+1}", fill="#2196F3")
+        
+    return img_copy
+
+# -------------------------------------------------------------
+# Gradio Orchestrator
+# -------------------------------------------------------------
+
+def process_pdf(pdf_file, mode, doc_layout_threshold, tatr_threshold, progress=gr.Progress()):
+    if not pdf_file:
+        return None, [], []
+        
+    progress(0.05, "Converting PDF to 300 DPI Images...")
+    pages = convert_pdf_to_images(pdf_file.name)
+    
+    progress(0.15, "Loading Layout Detection Model...")
+    load_layout_model()
+    
+    sheets_data = {}
+    visual_pages = []
+    visual_grids = []
+    
+    table_global_counter = 1
+    
+    for page_idx, page_img in enumerate(pages):
+        progress(0.20 + (page_idx / len(pages)) * 0.10, f"Analyzing page {page_idx+1} layout...")
+        tables = detect_tables(page_img, confidence_threshold=doc_layout_threshold)
+        
+        if not tables:
+            visual_pages.append(page_img)
+            continue
+            
+        page_with_boxes = draw_table_boxes(page_img, tables)
+        visual_pages.append(page_with_boxes)
+        
+        for t_idx, table in enumerate(tables):
+            box = table["box"]
+            # Crop table image
+            xmin, ymin, xmax, ymax = box
+            # Clip bounds
+            xmin = max(0, xmin)
+            ymin = max(0, ymin)
+            xmax = min(page_img.width, xmax)
+            ymax = min(page_img.height, ymax)
+            
+            table_crop = page_img.crop((xmin, ymin, xmax, ymax))
+            sheet_name = f"Page{page_idx+1}_Table{t_idx+1}"
+            
+            if mode == "Hybrid Grid Mode (PP-DocLayoutV3 + TATR + GLM-OCR)":
+                progress(0.35, f"Detecting structural grid for {sheet_name}...")
+                rows, columns, spanning = extract_table_structure(table_crop, confidence_threshold=tatr_threshold)
+                
+                grid_img = draw_structure_grid(table_crop, rows, columns)
+                visual_grids.append((grid_img, f"{sheet_name} Structure Grid"))
+                
+                progress(0.40, f"Loading GLM-OCR model...")
+                load_glm_model()
+                
+                # Setup custom progress callback for cell OCRs
+                def progress_cb(frac, desc):
+                    progress(0.45 + frac * 0.50, desc)
+                    
+                df, grid_spanning_map = build_grid_and_ocr(
+                    table_crop, 
+                    rows, 
+                    columns, 
+                    spanning, 
+                    progress_callback=progress_cb
+                )
+                
+                sheets_data[sheet_name] = {
+                    "df": df,
+                    "grid_spanning_map": grid_spanning_map
+                }
+            else:
+                # End-to-End Table Mode
+                progress(0.40, f"Loading GLM-OCR model...")
+                load_glm_model()
+                
+                progress(0.50, f"Running GLM-OCR Table Recognition on {sheet_name}...")
+                md_text = run_glm_ocr(table_crop, prompt="Table Recognition:")
+                df = parse_markdown_table(md_text)
+                
+                # Crop visualization
+                visual_grids.append((table_crop, f"{sheet_name} Crop"))
+                
+                sheets_data[sheet_name] = {
+                    "df": df,
+                    "grid_spanning_map": {}
+                }
+                
+            table_global_counter += 1
+            
+    if not sheets_data:
+        # If no tables found, create a placeholder sheet
+        sheets_data["No Tables Found"] = {
+            "df": pd.DataFrame([["No tables were detected in the uploaded PDF."]]),
+            "grid_spanning_map": {}
+        }
+        
+    progress(0.95, "Generating styled Excel workbook...")
+    temp_dir = tempfile.gettempdir()
+    excel_path = os.path.join(temp_dir, f"extracted_tables_{os.getpid()}.xlsx")
+    generate_excel_workbook(sheets_data, excel_path)
+    
+    progress(1.0, "Complete!")
+    
+    # Format dataframes list for preview tab
+    df_previews = []
+    for sheet_name, table_dict in sheets_data.items():
+        df_previews.append(gr.DataFrame(value=table_dict["df"], label=sheet_name, interactive=False))
+        
+    return excel_path, visual_pages, visual_grids
+
+# -------------------------------------------------------------
+# Gradio Interface Custom CSS & Styling
+# -------------------------------------------------------------
+
+custom_css = """
+body {
+    background-color: #0b0f19;
+}
+.gradio-container {
+    font-family: 'Outfit', sans-serif !important;
+}
+.header-box {
+    text-align: center;
+    background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
+    padding: 2.5rem;
+    border-radius: 12px;
+    margin-bottom: 2rem;
+    box-shadow: 0 4px 20px rgba(0,0,0,0.4);
+    color: white;
+}
+.header-box h1 {
+    font-size: 2.5rem;
+    font-weight: 800;
+    margin-bottom: 0.5rem;
+    letter-spacing: -1px;
+}
+.header-box p {
+    font-size: 1.1rem;
+    opacity: 0.9;
+}
+.primary-btn {
+    background: linear-gradient(135deg, #FF5722 0%, #E91E63 100%) !important;
+    border: none !important;
+    color: white !important;
+    font-weight: bold !important;
+}
+.secondary-btn {
+    background-color: #1e293b !important;
+    border: 1px solid #334155 !important;
+    color: white !important;
+}
+"""
+
+with gr.Blocks() as demo:
+    with gr.Column(elem_classes="header-box"):
+        gr.Markdown("# 📊 Multi-Model PDF to Excel Table Parser")
+        gr.Markdown(
+            "An enterprise-grade document extraction pipeline leveraging layout segmenters (PP-DocLayoutV3), "
+            "grid recognizers (Table Transformer), and state-of-the-art vision-language transcriptions (GLM-OCR)."
+        )
+        
+    with gr.Row():
+        with gr.Column(scale=2):
+            pdf_input = gr.File(label="Upload PDF Document", file_types=[".pdf"])
+            
+            with gr.Accordion("⚙️ Pipeline Configurations", open=True):
+                mode = gr.Dropdown(
+                    choices=[
+                        "Hybrid Grid Mode (PP-DocLayoutV3 + TATR + GLM-OCR)",
+                        "End-to-End Table Mode (PP-DocLayoutV3 + GLM-OCR Table Recognition)"
+                    ],
+                    value="Hybrid Grid Mode (PP-DocLayoutV3 + TATR + GLM-OCR)",
+                    label="Pipeline Processing Mode",
+                    info="Hybrid uses coordinates and merges; End-to-End transcribes directly."
+                )
+                
+                doc_layout_threshold = gr.Slider(
+                    minimum=0.1,
+                    maximum=0.9,
+                    value=0.4,
+                    step=0.05,
+                    label="PP-DocLayoutV3 Confidence (Table Detection)",
+                    info="Lower values detect more tables; higher values reduce false positives."
+                )
+                
+                tatr_threshold = gr.Slider(
+                    minimum=0.5,
+                    maximum=0.95,
+                    value=0.8,
+                    step=0.05,
+                    label="Table Transformer Confidence (Grid Structure)",
+                    info="Confidence threshold for rows/columns/spanning cell components."
+                )
+                
+            submit_btn = gr.Button("Convert and Extract Tables", variant="primary", elem_classes="primary-btn")
+            
+        with gr.Column(scale=3):
+            excel_output = gr.File(label="📥 Download Extracted Excel Workbook")
+            
+            with gr.Tabs():
+                with gr.TabItem("🖼️ Layout Detection Bboxes"):
+                    page_gallery = gr.Gallery(label="Page layout overview", columns=2, height=600)
+                    
+                with gr.TabItem("🕸️ Table Grids / Crops"):
+                    grid_gallery = gr.Gallery(label="Isolated tables and grids", columns=2, height=600)
+
+    # Trigger processing
+    submit_btn.click(
+        fn=process_pdf,
+        inputs=[pdf_input, mode, doc_layout_threshold, tatr_threshold],
+        outputs=[excel_output, page_gallery, grid_gallery]
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        theme=gr.themes.Soft(primary_hue="orange", secondary_hue="slate"), 
+        css=custom_css
+    )