Upload 4 files

Dockerfile

@@ -1,48 +1,31 @@
-FROM python:3.9-slim
+FROM python:3.10-slim
 
-# Set working directory
-WORKDIR /app
-
-# Install system dependencies (minimal)
-RUN apt-get update && \
-    apt-get install -y \
-    default-jre \
+RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
-    libreoffice \
-    libreoffice-writer \
-    libreoffice-calc \
-    libreoffice-java-common \
-    libgl1 \
-    libglib2.0-0 \
-    && apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
 
-# Reduce cache issues
-ENV XDG_CACHE_HOME=/tmp/.cache
-ENV NUMBA_CACHE_DIR=/tmp/.numba_cache
+# Non-root user required by Hugging Face Spaces
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
 
-# Copy requirements
-COPY requirements.txt .
+WORKDIR /home/user/app
 
-# Install Python dependencies
-RUN pip install --no-cache-dir -r requirements.txt
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
 
-# Copy app
-COPY main.py .
+COPY --chown=user main.py .
 
-# Create folders
 RUN mkdir -p uploads outputs
 
-# Expose port
 EXPOSE 7860
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
-  CMD curl -f http://localhost:7860/health || exit 1
-
-# Environment
-ENV FLASK_ENV=production
 ENV PYTHONUNBUFFERED=1
 
-# Run
-CMD ["python", "main.py"]
+HEALTHCHECK --interval=30s --timeout=10s --start-period=20s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+CMD ["python", "main.py"]

main.py

@@ -1,829 +1,588 @@
-
 from flask import Flask, request, send_file, jsonify
 from flask_cors import CORS
-import fitz  # PyMuPDF
+import fitz
 from docx import Document
-from docx.shared import Pt, RGBColor, Inches
+from docx.shared import Pt, RGBColor, Inches, Emu
 from docx.enum.text import WD_ALIGN_PARAGRAPH
-import tabula
+from docx.oxml.ns import qn
+from docx.oxml import OxmlElement
 from openpyxl import Workbook
-from openpyxl.styles import Font, Alignment, PatternFill
+from openpyxl.styles import Font, Alignment, PatternFill, Border, Side
 import os
-import tempfile
-import logging
-import threading, time, requests
-from dotenv import load_dotenv
-from werkzeug.utils import secure_filename
-import subprocess
-import shutil
-
-
-import numpy as np
-from PIL import Image
-import onnxruntime as ort
 import io
 import base64
-
-
-############################################
-import numpy as np
-from PIL import Image
-import onnxruntime as ort
-import io
-import base64
-
-import urllib.parse
-import random
-
-import fitz
-from docx import Document
-from openpyxl import Workbook
-from pdf2docx import Converter
 import tempfile
-import os
-from io import BytesIO
-import math
-from PyPDF2 import PdfMerger
-from flask_cors import CORS
-
-import base64
-from google import genai
-from google.genai import types
-from PIL import Image
-
-import threading, time, requests
-import os
+import logging
+import threading
+import time
+import requests
 from dotenv import load_dotenv
 from werkzeug.utils import secure_filename
 
-############################################
-
-    
+try:
+    import numpy as np
+    from PIL import Image
+    import onnxruntime as ort
+    BG_AVAILABLE = True
+except ImportError:
+    BG_AVAILABLE = False
 
 basedir = os.path.abspath(os.path.dirname(__file__))
 load_dotenv(os.path.join(basedir, '.env'))
 
-# Upload and output folders
 UPLOAD_FOLDER = os.path.join(basedir, 'uploads')
 OUTPUT_FOLDER = os.path.join(basedir, 'outputs')
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 os.makedirs(OUTPUT_FOLDER, exist_ok=True)
 
-app = Flask(__name__, static_folder='static', template_folder='templates')
+app = Flask(__name__)
 CORS(app)
-session = ort.InferenceSession('u2net.onnx')
-
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Load ONNX model for background removal
-session = ort.InferenceSession('u2net.onnx')
-LIBREOFFICE_AVAILABLE = False
+session = None
+if BG_AVAILABLE:
+    try:
+        model_path = os.path.join(basedir, 'u2net.onnx')
+        if os.path.exists(model_path):
+            session = ort.InferenceSession(model_path)
+            logger.info("ONNX model loaded")
+    except Exception as e:
+        logger.warning(f"ONNX not loaded: {e}")
 
 
-# Check LibreOffice availability
-try:
-    result = subprocess.run(['libreoffice', '--version'], capture_output=True, text=True, timeout=5)
-    if result.returncode == 0:
-        LIBREOFFICE_AVAILABLE = True
-        logger.info(f"LibreOffice available: {result.stdout.strip()}")
-    else:
-        logger.warning("LibreOffice not available")
-except Exception as e:
-    logger.warning(f"LibreOffice check failed: {e}")
-
-
-
-
-# Background task for keeping service alive
-def preprocess(image: Image.Image):
-    image = image.convert('RGB').resize((320, 320))
-    img_np = np.array(image).astype(np.float32) / 255.0
-    img_np = np.transpose(img_np, (2, 0, 1))
-    img_np = np.expand_dims(img_np, axis=0)
-    return img_np
-
-def postprocess(mask, orig_size):
-    mask = mask.squeeze()
-    mask = (mask - mask.min()) / (mask.max() - mask.min())
-    mask = Image.fromarray((mask * 255).astype(np.uint8)).resize(orig_size)
-    return mask
-
-def remove_background(image):
-    input_tensor = preprocess(image)
-    result = session.run(None, {'input.1': input_tensor})[0]
-    mask = postprocess(result[0], image.size)
-
-    image = image.convert("RGBA")
-    datas = image.getdata()
-    mask_data = mask.getdata()
-    newData = [(r, g, b, m) for (r, g, b, a), m in zip(datas, mask_data)]
-    image.putdata(newData)
-    return image
+def background_ping():
+    while True:
+        try:
+            url = os.environ.get('url')
+            if url:
+                requests.get(url, timeout=10)
+        except Exception:
+            pass
+        time.sleep(300)
 
-@app.route('/remove', methods=['POST'])
-def remove():
-    file = request.files['image']
-    img = Image.open(file.stream)
-    output = remove_background(img)
 
-    buffer = io.BytesIO()
-    output.save(buffer, format='PNG')
-    base64_img = base64.b64encode(buffer.getvalue()).decode('utf-8')
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def set_cell_border(cell):
+    tc = cell._tc
+    tcPr = tc.get_or_add_tcPr()
+    tcBorders = OxmlElement('w:tcBorders')
+    for edge in ('top', 'left', 'bottom', 'right'):
+        el = OxmlElement(f'w:{edge}')
+        el.set(qn('w:val'), 'single')
+        el.set(qn('w:sz'), '4')
+        el.set(qn('w:color'), '000000')
+        tcBorders.append(el)
+    tcPr.append(tcBorders)
+
 
-    return jsonify({'image': f'data:image/png;base64,{base64_img}'})
+def pt_to_emu(pt):
+    return int(pt * 12700)
+
+
+def detect_tables(page):
+    """Detect table regions using line analysis."""
+    tables = []
+    try:
+        paths = page.get_drawings()
+        rects = [p['rect'] for p in paths if p.get('rect') and p['rect'].width > 10 and p['rect'].height > 10]
+        if len(rects) > 3:
+            # Cluster overlapping rects into table regions
+            merged = []
+            for r in rects:
+                found = False
+                for m in merged:
+                    if abs(r.x0 - m.x0) < 50 and abs(r.y0 - m.y0) < 100:
+                        m.x0 = min(m.x0, r.x0)
+                        m.y0 = min(m.y0, r.y0)
+                        m.x1 = max(m.x1, r.x1)
+                        m.y1 = max(m.y1, r.y1)
+                        found = True
+                        break
+                if not found:
+                    merged.append(fitz.Rect(r))
+            tables = [r for r in merged if r.width > 50 and r.height > 20]
+    except Exception:
+        pass
+    return tables
+
+
+def extract_table_data(page, table_rect):
+    """Extract text from table region grouped by rows/cols."""
+    words = page.get_text("words", clip=table_rect)
+    if not words:
+        return []
+    words.sort(key=lambda w: (round(w[1] / 5) * 5, w[0]))
+    rows = {}
+    for w in words:
+        row_key = round(w[1] / 8) * 8
+        rows.setdefault(row_key, []).append(w)
+    return [sorted(r, key=lambda w: w[0]) for r in sorted(rows.values(), key=lambda r: r[0][1])]
+
+
+# ── routes ────────────────────────────────────────────────────────────────────
 
 @app.route('/')
 def index():
     return jsonify({
-        'service': 'AI One - Unified API',
-        'version': '1.0',
-        'endpoints': {
-            '/health': 'GET - Health check',
-            '/bg_remove': 'GET - Background removal info',
-            '/remove': 'POST - Remove background from image',
-            '/pdf-to-word': 'POST - Convert PDF to Word (DOCX)',
-            '/pdf-to-excel': 'POST - Convert PDF to Excel (XLSX)',
-            '/compress': 'POST - Compress PDF file'
-        },
-        'features': {
-            'background_removal': 'Remove background from images using U2-Net',
-            'pdf_to_word': 'Convert PDF with formatting preservation',
-            'pdf_to_excel': 'Extract tables from PDF to Excel',
-            'pdf_compress': 'Compress PDF files with quality presets'
-        }
+        'service': 'AI One API',
+        'version': '3.0',
+        'endpoints': ['/health', '/pdf-to-word', '/pdf-to-excel', '/compress', '/remove']
     })
 
+
 @app.route('/health')
 def health():
     return jsonify({
         'status': 'healthy',
-        'service': 'ai-one-unified-api',
-        'endpoints_available': ['pdf-to-word', 'pdf-to-excel', 'compress'] + (['bg_remove', 'remove'] if BACKGROUND_REMOVAL_AVAILABLE and session else []),
-        'features': {
-            'pdf_to_word': True,
-            'pdf_to_excel': True,
-            'pdf_compress': True,
-            'background_removal': BACKGROUND_REMOVAL_AVAILABLE and session is not None,
-            'libreoffice_conversion': LIBREOFFICE_AVAILABLE
-        }
+        'background_removal': BG_AVAILABLE and session is not None
     })
 
 
+@app.route('/remove', methods=['POST'])
+def remove():
+    if not BG_AVAILABLE or session is None:
+        return jsonify({'error': 'Background removal not available'}), 503
+    try:
+        if 'image' not in request.files:
+            return jsonify({'error': 'No image provided'}), 400
+        img = Image.open(request.files['image'].stream)
+        orig_size = img.size
+        inp = img.convert('RGB').resize((320, 320))
+        arr = np.expand_dims(np.transpose(np.array(inp).astype(np.float32) / 255.0, (2, 0, 1)), 0)
+        mask = session.run(None, {'input.1': arr})[0][0].squeeze()
+        mask = (mask - mask.min()) / (mask.max() - mask.min())
+        mask = Image.fromarray((mask * 255).astype(np.uint8)).resize(orig_size)
+        out = img.convert('RGBA')
+        out.putdata([(r, g, b, m) for (r, g, b, a), m in zip(out.getdata(), mask.getdata())])
+        buf = io.BytesIO()
+        out.save(buf, format='PNG')
+        return jsonify({'image': 'data:image/png;base64,' + base64.b64encode(buf.getvalue()).decode()})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
 @app.route('/pdf-to-word', methods=['POST'])
 def pdf_to_word():
     temp_pdf = None
     temp_docx = None
-    
+    img_temps = []
     try:
         if 'pdf' not in request.files:
             return jsonify({'error': 'No PDF file provided'}), 400
-        
-        pdf_file = request.files['pdf']
-        
-        if pdf_file.filename == '':
-            return jsonify({'error': 'Empty filename'}), 400
-        
-        if not pdf_file.filename.lower().endswith('.pdf'):
+        f = request.files['pdf']
+        if not f.filename.lower().endswith('.pdf'):
             return jsonify({'error': 'File must be a PDF'}), 400
-        
-        # Save uploaded PDF to temp file
+
         temp_pdf = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
-        pdf_file.save(temp_pdf.name)
+        f.save(temp_pdf.name)
         temp_pdf.close()
-        
-        logger.info(f"Processing PDF to Word: {pdf_file.filename}")
-        
-        # Try LibreOffice conversion first (best quality)
-        if LIBREOFFICE_AVAILABLE:
-            try:
-                # Create output directory
-                output_dir = tempfile.mkdtemp()
-                
-                # Use LibreOffice headless mode for conversion
-                cmd = [
-                    'libreoffice',
-                    '--headless',
-                    '--convert-to', 'docx',
-                    '--outdir', output_dir,
-                    temp_pdf.name
-                ]
-                
-                result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-                
-                # LibreOffice creates file with original name + .docx
-                pdf_basename = os.path.basename(temp_pdf.name)
-                converted_file = os.path.join(output_dir, os.path.splitext(pdf_basename)[0] + '.docx')
-                
-                if os.path.exists(converted_file) and os.path.getsize(converted_file) > 0:
-                    logger.info(f"LibreOffice conversion successful: {converted_file}")
-                    
-                    response = send_file(
-                        converted_file,
-                        mimetype='application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-                        as_attachment=True,
-                        download_name='converted.docx'
-                    )
-                    
-                    # Cleanup
-                    try:
-                        shutil.rmtree(output_dir)
-                    except:
-                        pass
-                    
-                    return response
-                else:
-                    logger.warning(f"LibreOffice conversion failed: {result.stderr}")
-                    # Cleanup
-                    try:
-                        shutil.rmtree(output_dir)
-                    except:
-                        pass
-            except Exception as lo_error:
-                logger.warning(f"LibreOffice conversion error: {lo_error}")
-        
-        # Fallback to PyMuPDF method
-        logger.info("Using PyMuPDF fallback conversion")
-        
-        # Open PDF with PyMuPDF
+
         doc = fitz.open(temp_pdf.name)
         word_doc = Document()
-        
-        # Set document margins to match PDF
-        sections = word_doc.sections
-        for section in sections:
+
+        # Page setup matching PDF
+        first_page = doc[0]
+        pdf_w = first_page.rect.width
+        pdf_h = first_page.rect.height
+        is_landscape = pdf_w > pdf_h
+
+        for section in word_doc.sections:
+            if is_landscape:
+                section.page_width = Inches(pdf_h / 72)
+                section.page_height = Inches(pdf_w / 72)
+                section.orientation = 1  # landscape
+            else:
+                section.page_width = Inches(pdf_w / 72)
+                section.page_height = Inches(pdf_h / 72)
             section.top_margin = Inches(0.5)
             section.bottom_margin = Inches(0.5)
-            section.left_margin = Inches(0.75)
-            section.right_margin = Inches(0.75)
-        
-        # Process each page
-        for page_num in range(len(doc)):
-            page = doc[page_num]
-            
-            # Get page dimensions
+            section.left_margin = Inches(0.5)
+            section.right_margin = Inches(0.5)
+
+        usable_width = (pdf_w / 72) - 1.0  # inches after margins
+
+        for page_num, page in enumerate(doc):
             page_width = page.rect.width
-            page_height = page.rect.height
-            
-            # Extract text blocks with formatting (sorted by position)
-            blocks = page.get_text("dict")["blocks"]
-            
-            # Sort blocks by vertical position (top to bottom)
-            blocks = sorted(blocks, key=lambda b: (b.get("bbox", [0, 0, 0, 0])[1], b.get("bbox", [0, 0, 0, 0])[0]))
-            
+
+            # Collect all blocks sorted top-to-bottom, left-to-right
+            blocks = sorted(
+                page.get_text("dict")["blocks"],
+                key=lambda b: (round(b["bbox"][1] / 5) * 5, b["bbox"][0])
+            )
+
+            # Detect table regions on this page
+            table_rects = detect_tables(page)
+            table_bboxes = [list(r) for r in table_rects]
+
+            def in_table(bbox):
+                for tr in table_bboxes:
+                    if bbox[0] >= tr[0] - 5 and bbox[1] >= tr[1] - 5 and bbox[2] <= tr[2] + 5 and bbox[3] <= tr[3] + 5:
+                        return True
+                return False
+
+            # Render tables first
+            rendered_tables = set()
+            for ti, tr in enumerate(table_rects):
+                rows = extract_table_data(page, tr)
+                if not rows or ti in rendered_tables:
+                    continue
+                rendered_tables.add(ti)
+                num_cols = max(len(r) for r in rows)
+                if num_cols == 0:
+                    continue
+                tbl = word_doc.add_table(rows=len(rows), cols=num_cols)
+                tbl.style = 'Table Grid'
+                for ri, row in enumerate(rows):
+                    for ci, word_item in enumerate(row):
+                        if ci < num_cols:
+                            cell = tbl.cell(ri, ci)
+                            cell.text = word_item[4]
+                            cell.paragraphs[0].runs[0].font.size = Pt(9) if cell.paragraphs[0].runs else None
+                            set_cell_border(cell)
+                word_doc.add_paragraph()
+
+            # Process text and image blocks
             for block in blocks:
-                if block["type"] == 0:  # Text block
-                    # Check if block looks like a table (multiple columns)
-                    lines = block.get("lines", [])
-                    
-                    for line in lines:
-                        # Get line position for alignment
-                        bbox = line.get("bbox", [0, 0, 0, 0])
-                        line_left = bbox[0]
-                        line_right = bbox[2]
-                        line_center = (line_left + line_right) / 2
-                        
-                        paragraph = word_doc.add_paragraph()
-                        
-                        # Determine alignment based on position
-                        if line_left < page_width * 0.15:  # Left aligned
-                            paragraph.alignment = WD_ALIGN_PARAGRAPH.LEFT
-                        elif line_right > page_width * 0.85:  # Right aligned
-                            paragraph.alignment = WD_ALIGN_PARAGRAPH.RIGHT
-                        elif abs(line_center - page_width / 2) < page_width * 0.1:  # Center
-                            paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                if block["type"] == 0:
+                    if in_table(block["bbox"]):
+                        continue
+
+                    for line in block.get("lines", []):
+                        bbox = line["bbox"]
+                        cx = (bbox[0] + bbox[2]) / 2
+                        line_width = bbox[2] - bbox[0]
+
+                        para = word_doc.add_paragraph()
+                        pf = para.paragraph_format
+                        pf.space_before = Pt(0)
+                        pf.space_after = Pt(1)
+
+                        # Left indent
+                        left_indent = bbox[0] / 72
+                        if left_indent > 0.1:
+                            pf.left_indent = Inches(min(left_indent, usable_width * 0.5))
+
+                        # Alignment
+                        center_dist = abs(cx - page_width / 2)
+                        if center_dist < page_width * 0.08 and line_width < page_width * 0.6:
+                            para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                        elif bbox[0] > page_width * 0.55:
+                            para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
                         else:
-                            paragraph.alignment = WD_ALIGN_PARAGRAPH.LEFT
-                        
-                        # Process each span (text with same formatting)
+                            para.alignment = WD_ALIGN_PARAGRAPH.LEFT
+
                         for span in line.get("spans", []):
                             text = span.get("text", "")
-                            if not text.strip():
+                            if not text:
                                 continue
-                            
-                            run = paragraph.add_run(text)
-                            
-                            # Font properties
-                            font_name = span.get("font", "Calibri")
-                            font_size = span.get("size", 11)
-                            
-                            # Clean font name (remove subset prefix)
-                            if '+' in font_name:
-                                font_name = font_name.split('+')[1]
-                            
+                            run = para.add_run(text)
+
+                            # Font name
+                            fname = span.get("font", "Calibri")
+                            if '+' in fname:
+                                fname = fname.split('+', 1)[1]
+                            # Map common PDF fonts to Word fonts
+                            font_map = {
+                                'TimesNewRoman': 'Times New Roman',
+                                'Arial': 'Arial',
+                                'Helvetica': 'Arial',
+                                'Courier': 'Courier New',
+                                'Georgia': 'Georgia',
+                                'Verdana': 'Verdana',
+                            }
+                            for k, v in font_map.items():
+                                if k.lower() in fname.lower():
+                                    fname = v
+                                    break
                             try:
-                                run.font.name = font_name
-                            except:
-                                run.font.name = "Calibri"
-                            
-                            run.font.size = Pt(font_size)
-                            
-                            # Font style flags
+                                run.font.name = fname
+                            except Exception:
+                                run.font.name = 'Calibri'
+
+                            # Size
+                            size = span.get("size", 11)
+                            run.font.size = Pt(round(size * 10) / 10)
+
+                            # Style flags
                             flags = span.get("flags", 0)
-                            if flags & 2**4:  # Bold (bit 4)
-                                run.font.bold = True
-                            if flags & 2**1:  # Italic (bit 1)
-                                run.font.italic = True
-                            if flags & 2**0:  # Superscript (bit 0)
-                                run.font.underline = True
-                            
-                            # Font color
-                            color = span.get("color", 0)
-                            if color != 0:
-                                r = (color >> 16) & 0xFF
-                                g = (color >> 8) & 0xFF
-                                b = color & 0xFF
-                                try:
-                                    run.font.color.rgb = RGBColor(r, g, b)
-                                except:
-                                    pass
-                        
-                        # Add spacing between paragraphs
-                        paragraph.paragraph_format.space_after = Pt(0)
-                        paragraph.paragraph_format.space_before = Pt(0)
-                
-                elif block["type"] == 1:  # Image block
-                    try:
-                        # Get image reference
-                        image_info = block.get("image")
-                        if image_info:
-                            xref = image_info
-                        else:
-                            xref = block.get("xref", 0)
-                        
-                        if xref and xref > 0:
-                            try:
-                                # Extract image from PDF
-                                base_image = doc.extract_image(xref)
-                                image_bytes = base_image["image"]
-                                image_ext = base_image.get("ext", "png")
-                                
-                                # Get image dimensions from block bbox
-                                bbox = block.get("bbox", [0, 0, 0, 0])
-                                img_width = bbox[2] - bbox[0]
-                                img_height = bbox[3] - bbox[1]
-                                
-                                # Save image to temp file
-                                temp_img = tempfile.NamedTemporaryFile(delete=False, suffix=f".{image_ext}")
-                                temp_img.write(image_bytes)
-                                temp_img.close()
-                                
-                                # Add image to Word document
-                                try:
-                                    # Convert PDF points to inches (72 points = 1 inch)
-                                    width_inches = img_width / 72
-                                    height_inches = img_height / 72
-                                    
-                                    # Limit max width to 6.5 inches (standard page width with margins)
-                                    if width_inches > 6.5:
-                                        ratio = 6.5 / width_inches
-                                        width_inches = 6.5
-                                        height_inches = height_inches * ratio
-                                    
-                                    word_doc.add_picture(temp_img.name, width=Inches(width_inches))
-                                    logger.info(f"Added image: {width_inches:.2f}x{height_inches:.2f} inches")
-                                    
-                                    # Add spacing after image
-                                    word_doc.add_paragraph()
-                                except Exception as img_add_error:
-                                    logger.error(f"Failed to add image to document: {img_add_error}")
-                                
-                                # Clean up temp image
+                            run.font.bold = bool(flags & 16)
+                            run.font.italic = bool(flags & 2)
+                            run.font.underline = bool(flags & 4)
+
+                            # Color
+                            c = span.get("color", 0)
+                            if c and c != 0:
                                 try:
-                                    os.unlink(temp_img.name)
-                                except:
+                                    run.font.color.rgb = RGBColor((c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF)
+                                except Exception:
                                     pass
-                            except Exception as extract_error:
-                                logger.error(f"Failed to extract image xref {xref}: {extract_error}")
-                        else:
-                            logger.warning(f"Invalid image xref: {xref}")
-                    except Exception as img_error:
-                        logger.error(f"Image block processing error: {img_error}")
-            
-            # Add page break (except for last page)
+
+                elif block["type"] == 1:
+                    xref = block.get("xref", 0)
+                    if xref > 0:
+                        try:
+                            img_data = doc.extract_image(xref)
+                            bbox = block["bbox"]
+                            img_w_pt = bbox[2] - bbox[0]
+                            img_h_pt = bbox[3] - bbox[1]
+                            w_in = min(img_w_pt / 72, usable_width)
+                            h_in = (img_h_pt / img_w_pt) * w_in if img_w_pt > 0 else w_in
+
+                            ext = img_data.get('ext', 'png')
+                            if ext == 'jpx':
+                                ext = 'png'
+                            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=f'.{ext}')
+                            tmp.write(img_data["image"])
+                            tmp.close()
+                            img_temps.append(tmp.name)
+
+                            para = word_doc.add_paragraph()
+                            # Center image if it spans most of page width
+                            if w_in > usable_width * 0.5:
+                                para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                            run = para.add_run()
+                            run.add_picture(tmp.name, width=Inches(w_in))
+                            word_doc.add_paragraph().paragraph_format.space_after = Pt(2)
+                        except Exception as e:
+                            logger.warning(f"Image skip xref={xref}: {e}")
+
             if page_num < len(doc) - 1:
                 word_doc.add_page_break()
-        
+
         doc.close()
-        
-        # Save Word document
+
         temp_docx = tempfile.NamedTemporaryFile(delete=False, suffix='.docx')
         word_doc.save(temp_docx.name)
         temp_docx.close()
-        
-        logger.info(f"Word document created successfully: {temp_docx.name}")
-        
-        # Send file
-        response = send_file(
+
+        return send_file(
             temp_docx.name,
             mimetype='application/vnd.openxmlformats-officedocument.wordprocessingml.document',
             as_attachment=True,
             download_name='converted.docx'
         )
-        
-        return response
-    
+
     except Exception as e:
-        logger.error(f"Error converting PDF to Word: {str(e)}")
-        import traceback
-        logger.error(traceback.format_exc())
-        return jsonify({'error': f'Conversion failed: {str(e)}'}), 500
-    
+        logger.error(f"PDF to Word error: {e}", exc_info=True)
+        return jsonify({'error': str(e)}), 500
     finally:
-        # Cleanup temp files after response is sent
+        for t in img_temps:
+            try:
+                os.unlink(t)
+            except Exception:
+                pass
         try:
             if temp_pdf and os.path.exists(temp_pdf.name):
                 os.unlink(temp_pdf.name)
-        except Exception as cleanup_error:
-            logger.warning(f"Cleanup error: {cleanup_error}")
+        except Exception:
+            pass
+
 
 @app.route('/pdf-to-excel', methods=['POST'])
 def pdf_to_excel():
     temp_pdf = None
-    temp_excel = None
-    
+    temp_xlsx = None
     try:
         if 'pdf' not in request.files:
             return jsonify({'error': 'No PDF file provided'}), 400
-        
-        pdf_file = request.files['pdf']
-        
-        if pdf_file.filename == '':
-            return jsonify({'error': 'Empty filename'}), 400
-        
-        if not pdf_file.filename.lower().endswith('.pdf'):
+        f = request.files['pdf']
+        if not f.filename.lower().endswith('.pdf'):
             return jsonify({'error': 'File must be a PDF'}), 400
-        
-        # Save uploaded PDF to temp file
+
         temp_pdf = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
-        pdf_file.save(temp_pdf.name)
+        f.save(temp_pdf.name)
         temp_pdf.close()
-        
-        logger.info(f"Processing PDF to Excel: {pdf_file.filename}")
-        
-        # Try LibreOffice conversion first (best quality)
-        if LIBREOFFICE_AVAILABLE:
-            try:
-                # Create output directory
-                output_dir = tempfile.mkdtemp()
-                
-                # Use LibreOffice headless mode for conversion
-                cmd = [
-                    'libreoffice',
-                    '--headless',
-                    '--convert-to', 'xlsx',
-                    '--outdir', output_dir,
-                    temp_pdf.name
-                ]
-                
-                result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-                
-                # LibreOffice creates file with original name + .xlsx
-                pdf_basename = os.path.basename(temp_pdf.name)
-                converted_file = os.path.join(output_dir, os.path.splitext(pdf_basename)[0] + '.xlsx')
-                
-                if os.path.exists(converted_file) and os.path.getsize(converted_file) > 0:
-                    logger.info(f"LibreOffice conversion successful: {converted_file}")
-                    
-                    response = send_file(
-                        converted_file,
-                        mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-                        as_attachment=True,
-                        download_name='converted.xlsx'
-                    )
-                    
-                    # Cleanup
-                    try:
-                        shutil.rmtree(output_dir)
-                    except:
-                        pass
-                    
-                    return response
-                else:
-                    logger.warning(f"LibreOffice conversion failed: {result.stderr}")
-                    # Cleanup
-                    try:
-                        shutil.rmtree(output_dir)
-                    except:
-                        pass
-            except Exception as lo_error:
-                logger.warning(f"LibreOffice conversion error: {lo_error}")
-        
-        # Fallback to tabula + PyMuPDF method
-        logger.info("Using tabula/PyMuPDF fallback conversion")
-        
-        # Create Excel workbook
+
+        doc = fitz.open(temp_pdf.name)
         wb = Workbook()
-        wb.remove(wb.active)  # Remove default sheet
-        
-        # Try to extract tables using tabula with better settings
-        tables_extracted = False
-        try:
-            # Use multiple strategies for better table detection
-            tables = tabula.read_pdf(
-                temp_pdf.name, 
-                pages='all', 
-                multiple_tables=True,
-                lattice=True,  # Better for tables with borders
-                guess=True,    # Auto-detect table areas
-                pandas_options={'header': None}  # Don't assume first row is header
-            )
-            
-            if tables and len(tables) > 0:
-                logger.info(f"Found {len(tables)} tables using lattice mode")
-                
-                for idx, df in enumerate(tables):
-                    if df.empty:
+        wb.remove(wb.active)
+
+        thin = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        header_fill = PatternFill("solid", fgColor="D9D9D9")
+        header_font = Font(bold=True, size=11)
+
+        for page_num, page in enumerate(doc):
+            page_width = page.rect.width
+
+            # Extract words with position info
+            words = page.get_text("words")
+            if not words:
+                continue
+
+            # Group words into rows by Y position (tolerance 3pt)
+            rows = {}
+            for w in words:
+                y_key = round(w[1] / 3) * 3
+                rows.setdefault(y_key, []).append(w)
+
+            sorted_rows = [sorted(r, key=lambda w: w[0]) for r in sorted(rows.values(), key=lambda r: r[0][1])]
+
+            if not sorted_rows:
+                continue
+
+            # Detect columns by X position clustering
+            all_x = sorted(set(round(w[0] / 10) * 10 for row in sorted_rows for w in row))
+            col_positions = []
+            for x in all_x:
+                if not col_positions or x - col_positions[-1] > 20:
+                    col_positions.append(x)
+
+            def get_col_idx(x):
+                best = 0
+                best_dist = abs(x - col_positions[0])
+                for i, cx in enumerate(col_positions):
+                    d = abs(x - cx)
+                    if d < best_dist:
+                        best_dist = d
+                        best = i
+                return best
+
+            ws = wb.create_sheet(f"Page_{page_num + 1}")
+            num_cols = max(len(col_positions), 1)
+
+            # Detect if first row is a header (larger font or bold)
+            first_row_blocks = page.get_text("dict")["blocks"]
+            header_y = sorted_rows[0][0][1] if sorted_rows else 0
+            is_header_row = False
+            for blk in first_row_blocks:
+                if blk["type"] == 0:
+                    for line in blk.get("lines", []):
+                        if abs(line["bbox"][1] - header_y) < 5:
+                            for span in line.get("spans", []):
+                                if span.get("flags", 0) & 16 or span.get("size", 0) > 12:
+                                    is_header_row = True
+
+            for ri, row in enumerate(sorted_rows, 1):
+                # Merge words that are close together into cells
+                cells = {}
+                for w in row:
+                    ci = get_col_idx(w[0])
+                    cells[ci] = (cells.get(ci, '') + ' ' + w[4]).strip()
+
+                for ci, text in cells.items():
+                    if ci >= num_cols:
                         continue
-                    
-                    sheet_name = f"Table_{idx + 1}"
-                    ws = wb.create_sheet(title=sheet_name)
-                    
-                    # Write data with proper formatting
-                    for row_idx, row in enumerate(df.values, start=1):
-                        for col_idx, value in enumerate(row, start=1):
-                            cell = ws.cell(row=row_idx, column=col_idx)
-                            
-                            # Handle different data types
-                            if value is not None and str(value).strip():
-                                try:
-                                    # Try to convert to number
-                                    if isinstance(value, str) and value.replace('.', '', 1).replace('-', '', 1).isdigit():
-                                        cell.value = float(value)
-                                    else:
-                                        cell.value = str(value)
-                                except:
-                                    cell.value = str(value)
-                            
-                            # Format first row as header
-                            if row_idx == 1:
-                                cell.font = Font(bold=True, size=11)
-                                cell.fill = PatternFill(start_color="E0E0E0", end_color="E0E0E0", fill_type="solid")
-                                cell.alignment = Alignment(horizontal='center', vertical='center')
-                            else:
-                                cell.alignment = Alignment(horizontal='left', vertical='top', wrap_text=True)
-                    
-                    # Auto-adjust column widths
-                    for column in ws.columns:
-                        max_length = 0
-                        column_letter = column[0].column_letter
-                        for cell in column:
-                            try:
-                                if cell.value:
-                                    max_length = max(max_length, len(str(cell.value)))
-                            except:
-                                pass
-                        adjusted_width = min(max(max_length + 2, 10), 50)
-                        ws.column_dimensions[column_letter].width = adjusted_width
-                    
-                    # Add borders to all cells
-                    from openpyxl.styles import Border, Side
-                    thin_border = Border(
-                        left=Side(style='thin'),
-                        right=Side(style='thin'),
-                        top=Side(style='thin'),
-                        bottom=Side(style='thin')
-                    )
-                    for row in ws.iter_rows():
-                        for cell in row:
-                            cell.border = thin_border
-                
-                tables_extracted = True
-                logger.info(f"Successfully extracted {len(tables)} tables")
-        except Exception as table_error:
-            logger.warning(f"Lattice table extraction failed: {table_error}")
-        
-        # Try stream mode if lattice failed
-        if not tables_extracted:
-            try:
-                tables = tabula.read_pdf(
-                    temp_pdf.name,
-                    pages='all',
-                    multiple_tables=True,
-                    stream=True,  # Better for tables without borders
-                    guess=True
-                )
-                
-                if tables and len(tables) > 0:
-                    logger.info(f"Found {len(tables)} tables using stream mode")
-                    
-                    for idx, df in enumerate(tables):
-                        if df.empty:
-                            continue
-                        
-                        sheet_name = f"Table_{idx + 1}"
-                        ws = wb.create_sheet(title=sheet_name)
-                        
-                        # Write data
-                        for row_idx, row in enumerate(df.values, start=1):
-                            for col_idx, value in enumerate(row, start=1):
-                                cell = ws.cell(row=row_idx, column=col_idx)
-                                if value is not None and str(value).strip():
-                                    cell.value = str(value)
-                                
-                                if row_idx == 1:
-                                    cell.font = Font(bold=True, size=11)
-                                    cell.fill = PatternFill(start_color="E0E0E0", end_color="E0E0E0", fill_type="solid")
-                                    cell.alignment = Alignment(horizontal='center', vertical='center')
-                                else:
-                                    cell.alignment = Alignment(horizontal='left', vertical='top', wrap_text=True)
-                        
-                        # Auto-adjust columns
-                        for column in ws.columns:
-                            max_length = 0
-                            column_letter = column[0].column_letter
-                            for cell in column:
-                                try:
-                                    if cell.value:
-                                        max_length = max(max_length, len(str(cell.value)))
-                                except:
-                                    pass
-                            adjusted_width = min(max(max_length + 2, 10), 50)
-                            ws.column_dimensions[column_letter].width = adjusted_width
-                    
-                    tables_extracted = True
-                    logger.info(f"Successfully extracted {len(tables)} tables with stream mode")
-            except Exception as stream_error:
-                logger.warning(f"Stream table extraction failed: {stream_error}")
-        
-        # Fallback: Extract text using PyMuPDF if no tables found
-        if not tables_extracted:
-            logger.info("No tables found, extracting text content")
-            
-            doc = fitz.open(temp_pdf.name)
-            
-            for page_num in range(len(doc)):
-                page = doc[page_num]
-                text = page.get_text()
-                
-                if not text.strip():
-                    continue
-                
-                sheet_name = f"Page_{page_num + 1}"
-                ws = wb.create_sheet(title=sheet_name)
-                
-                # Split text into lines and write to Excel
-                lines = text.split('\n')
-                for row_idx, line in enumerate(lines, start=1):
-                    if line.strip():
-                        # Try to detect columns by splitting on multiple spaces
-                        columns = [col.strip() for col in line.split('  ') if col.strip()]
-                        
-                        if len(columns) > 1:
-                            # Multiple columns detected
-                            for col_idx, col_text in enumerate(columns, start=1):
-                                cell = ws.cell(row=row_idx, column=col_idx, value=col_text)
-                                cell.alignment = Alignment(horizontal='left', vertical='top', wrap_text=True)
-                        else:
-                            # Single column
-                            cell = ws.cell(row=row_idx, column=1, value=line.strip())
-                            cell.alignment = Alignment(horizontal='left', vertical='top', wrap_text=True)
-                
-                # Auto-adjust column widths
-                for column in ws.columns:
-                    max_length = 0
-                    column_letter = column[0].column_letter
-                    for cell in column:
-                        try:
-                            if cell.value:
-                                max_length = max(max_length, len(str(cell.value)))
-                        except:
-                            pass
-                    adjusted_width = min(max(max_length + 2, 10), 100)
-                    ws.column_dimensions[column_letter].width = adjusted_width
-            
-            doc.close()
-            logger.info(f"Extracted text from {len(doc)} pages")
-        
-        # If no sheets were created, add a default message
-        if len(wb.sheetnames) == 0:
-            ws = wb.create_sheet(title="Data")
-            ws['A1'] = "No data could be extracted from the PDF"
+                    cell = ws.cell(ri, ci + 1)
+                    # Try numeric
+                    clean = text.replace(',', '').strip()
+                    try:
+                        cell.value = int(clean) if clean.lstrip('-').isdigit() else float(clean)
+                    except Exception:
+                        cell.value = text
+
+                    if ri == 1 and is_header_row:
+                        cell.font = header_font
+                        cell.fill = header_fill
+                        cell.alignment = Alignment(horizontal='center', vertical='center')
+                    else:
+                        cell.alignment = Alignment(horizontal='left', vertical='top', wrap_text=True)
+                    cell.border = thin
+
+            # Auto column widths
+            for col in ws.columns:
+                w = max((len(str(c.value)) for c in col if c.value is not None), default=8)
+                ws.column_dimensions[col[0].column_letter].width = min(max(w + 2, 8), 50)
+
+            # Freeze header row
+            if is_header_row:
+                ws.freeze_panes = 'A2'
+
+        doc.close()
+
+        if not wb.sheetnames:
+            ws = wb.create_sheet("Data")
+            ws['A1'] = "No data extracted"
             ws['A1'].font = Font(bold=True)
-        
-        # Save Excel file
-        temp_excel = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx')
-        wb.save(temp_excel.name)
-        temp_excel.close()
-        
-        logger.info(f"Excel file created successfully: {temp_excel.name}")
-        
-        # Send file
-        response = send_file(
-            temp_excel.name,
+
+        temp_xlsx = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx')
+        wb.save(temp_xlsx.name)
+        temp_xlsx.close()
+
+        return send_file(
+            temp_xlsx.name,
             mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
             as_attachment=True,
             download_name='converted.xlsx'
         )
-        
-        return response
-    
+
     except Exception as e:
-        logger.error(f"Error converting PDF to Excel: {str(e)}")
-        import traceback
-        logger.error(traceback.format_exc())
-        return jsonify({'error': f'Conversion failed: {str(e)}'}), 500
-    
+        logger.error(f"PDF to Excel error: {e}", exc_info=True)
+        return jsonify({'error': str(e)}), 500
     finally:
-        # Cleanup temp files after response is sent
         try:
             if temp_pdf and os.path.exists(temp_pdf.name):
                 os.unlink(temp_pdf.name)
-        except Exception as cleanup_error:
-            logger.warning(f"Cleanup error: {cleanup_error}")
-
-def compress_pdf(input_path, output_path, preset="medium", target_kb=None):
-    doc = fitz.open(input_path)
-
-    preset_options = {
-        "low": {"garbage": 3, "deflate": True, "clean": True},
-        "medium": {"garbage": 2, "deflate": True, "clean": True},
-        "high": {"garbage": 1, "deflate": True, "clean": True},
-    }
-    opts = preset_options.get(preset, preset_options["medium"])
-
-    if target_kb:
-        step = 10
-        zoom = 1.0
-        while True:
-            new_doc = fitz.open()
-            for page in doc:
-                pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom))
-                rect = fitz.Rect(0, 0, pix.width, pix.height)
-                new_page = new_doc.new_page(width=pix.width, height=pix.height)
-                new_page.insert_image(rect, pixmap=pix)
-
-            new_doc.save(output_path, **opts)
-            size_kb = os.path.getsize(output_path) / 1024
-            new_doc.close()
-
-            if size_kb <= target_kb or zoom <= 0.3:
-                break
-            zoom -= 0.1
-    else:
-        doc.save(output_path, **opts)
-
-    doc.close()
+        except Exception:
+            pass
+
 
 @app.route('/compress', methods=['POST', 'GET'])
 def compress():
-    if request.method == 'POST':
-        try:
-            if "pdf" not in request.files:
-                return jsonify({"success": False, "error": "No file uploaded"}), 400
-        
-            file = request.files["pdf"]
-            if file.filename == '':
-                return jsonify({"success": False, "error": "Empty filename"}), 400
-            
-            preset = request.form.get("preset", "medium")
-            target_kb = request.form.get("target_kb")
-        
-            if target_kb:
-                try:
-                    target_kb = int(target_kb)
-                except:
-                    target_kb = None
-        
-            filename = secure_filename(file.filename)
-            input_path = os.path.join(UPLOAD_FOLDER, filename)
-            output_path = os.path.join(OUTPUT_FOLDER, "compressed_" + filename)
-            file.save(input_path)
-        
-            compress_pdf(input_path, output_path, preset, target_kb)
-            
-            return send_file(output_path, as_attachment=True, download_name="compressed_" + filename)
-        except Exception as e:
-            logger.error(f"Compression error: {str(e)}")
-            return jsonify({"success": False, "error": str(e)}), 500
-    
-    return jsonify({
-        'endpoint': '/compress',
-        'method': 'POST',
-        'description': 'Compress PDF file',
-        'parameters': {
-            'pdf': 'PDF file (multipart/form-data)',
-            'preset': 'Compression preset: low, medium, high (optional)',
-            'target_kb': 'Target file size in KB (optional)'
-        }
-    })
+    if request.method == 'GET':
+        return jsonify({'endpoint': '/compress', 'method': 'POST', 'params': ['pdf', 'preset', 'target_kb']})
+    try:
+        if 'pdf' not in request.files:
+            return jsonify({'error': 'No file uploaded'}), 400
+        file = request.files['pdf']
+        preset = request.form.get('preset', 'medium')
+        target_kb = request.form.get('target_kb')
+        if target_kb:
+            try:
+                target_kb = int(target_kb)
+            except Exception:
+                target_kb = None
+
+        filename = secure_filename(file.filename)
+        input_path = os.path.join(UPLOAD_FOLDER, filename)
+        output_path = os.path.join(OUTPUT_FOLDER, 'compressed_' + filename)
+        file.save(input_path)
+
+        opts = {
+            'low':    {'garbage': 3, 'deflate': True, 'clean': True},
+            'medium': {'garbage': 2, 'deflate': True, 'clean': True},
+            'high':   {'garbage': 1, 'deflate': True, 'clean': True},
+        }.get(preset, {'garbage': 2, 'deflate': True, 'clean': True})
+
+        doc = fitz.open(input_path)
+        if target_kb:
+            zoom = 1.0
+            while zoom > 0.3:
+                new_doc = fitz.open()
+                for page in doc:
+                    pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom))
+                    np_ = new_doc.new_page(width=pix.width, height=pix.height)
+                    np_.insert_image(fitz.Rect(0, 0, pix.width, pix.height), pixmap=pix)
+                new_doc.save(output_path, **opts)
+                new_doc.close()
+                if os.path.getsize(output_path) / 1024 <= target_kb:
+                    break
+                zoom -= 0.1
+        else:
+            doc.save(output_path, **opts)
+        doc.close()
+
+        return send_file(output_path, as_attachment=True, download_name='compressed_' + filename)
+    except Exception as e:
+        logger.error(f"Compress error: {e}")
+        return jsonify({'error': str(e)}), 500
+
 
-@app.route("/download/<filename>")
+@app.route('/download/<filename>')
 def download(filename):
     try:
-        safe_filename = secure_filename(filename)
-        return send_file(os.path.join(OUTPUT_FOLDER, safe_filename), as_attachment=True)
-    except Exception as e:
-        logger.error(f"Download error: {str(e)}")
-        return jsonify({"error": "File not found"}), 404
+        return send_file(os.path.join(OUTPUT_FOLDER, secure_filename(filename)), as_attachment=True)
+    except Exception:
+        return jsonify({'error': 'File not found'}), 404
+
 
 if __name__ == '__main__':
-    # Start background task in separate thread
-    thread = threading.Thread(target=background_task, daemon=True)
-    thread.start()
-    
+    threading.Thread(target=background_ping, daemon=True).start()
     port = int(os.environ.get('PORT', 7860))
-    logger.info(f"Starting server on port {port}")
+    logger.info(f"Starting on port {port}")
     app.run(host='0.0.0.0', port=port, debug=False)
-

packages.txt

@@ -1,4 +1 @@
-default-jre
-libreoffice
-libreoffice-writer
-libreoffice-calc
+curl

requirements.txt

@@ -1,33 +1,10 @@
-# Core dependencies
-flask==3.0.0
-flask-cors==4.0.0
-gunicorn==21.2.0
-requests==2.31.0
-python-dotenv==1.0.0
-
-# PDF processing
-PyMuPDF==1.23.8
-python-docx==1.1.0
-tabula-py==2.9.0
-openpyxl==3.1.2
-pandas==2.1.4
-
-onnxruntime
-pillow
-numpy
-
-####################
-pdf2docx
-pdfplumber
-PyMuPDF
-pandas
-openpyxl
-pymupdf
-PyPDF2
-flask-cors
-
-google-genai
-
-
-dotenv
-requests
+flask==3.0.3
+flask-cors==4.0.1
+gunicorn==22.0.0
+requests==2.32.3
+python-dotenv==1.0.1
+werkzeug==3.0.3
+PyMuPDF==1.24.5
+python-docx==1.1.2
+openpyxl==3.1.5
+lxml==5.2.2