Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,20 @@
 ---
-title: Pdf Detect Api
-emoji: 💻
+title: PDF Field Detector
+emoji: 📋
 colorFrom: blue
-colorTo: pink
+colorTo: green
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PDF Field Detector
+
+FastAPI service that detects form fields in PDFs.
+
+- **AcroForm PDFs**: extracts native widget positions
+- **Flat vector PDFs**: mines drawing layer for checkboxes, underlines, rectangles
+- **Scanned/image PDFs**: returns `needs_ml` signal for FFDNet fallback
+
+## API
+
+`POST /detect` — multipart form upload, returns JSON with field boxes as fractions 0..1.

app.py

@@ -0,0 +1,29 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from detect import detect_pdf
+
+app = FastAPI(title="PDF Field Detector")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["POST", "GET"],
+    allow_headers=["*"],
+)
+
+@app.get("/health")
+def health():
+    return {"ok": True}
+
+@app.post("/detect")
+async def detect(file: UploadFile = File(...)):
+    if not file.filename.lower().endswith(".pdf"):
+        raise HTTPException(400, "Only PDF files accepted")
+    pdf_bytes = await file.read()
+    if len(pdf_bytes) > 50 * 1024 * 1024:
+        raise HTTPException(413, "PDF too large (max 50MB)")
+    try:
+        pages = detect_pdf(pdf_bytes)
+        return {"pages": pages}
+    except Exception as e:
+        raise HTTPException(500, str(e))

detect.py

@@ -0,0 +1,133 @@
+"""
+Core PDF field detection logic.
+Handles three cases:
+  1. AcroForm PDF      → extract native widgets
+  2. Flat vector PDF   → extract from drawings layer (rectangles, lines)
+  3. Image/scanned PDF → return 'needs_ml' signal for FFDNet fallback
+"""
+import fitz
+from typing import Literal
+
+
+FieldType = Literal['checkbox', 'text', 'signature']
+
+
+def _label_near(x0, y0, x1, y1, text_spans):
+    """Find the nearest text label above or left of a rect."""
+    best, best_dist = '', 1e9
+    for span in text_spans:
+        sx0, sy0, sx1, sy1 = span['bbox']
+        # Candidate: text ends to the left, or is above (within 20pt)
+        if sx1 <= x0 + 5 and abs((sy0 + sy1) / 2 - (y0 + y1) / 2) < 20:
+            dist = x0 - sx1
+            if 0 <= dist < best_dist:
+                best, best_dist = span['text'], dist
+        elif sy1 <= y0 + 2 and sx0 >= x0 - 5 and sx1 <= x1 + 5:
+            dist = y0 - sy1
+            if 0 <= dist < best_dist:
+                best, best_dist = span['text'], dist
+    return best.strip()
+
+
+def detect_page(page) -> dict:
+    pw, ph = page.rect.width, page.rect.height
+    widgets  = list(page.widgets())
+    drawings = page.get_drawings()
+    images   = page.get_images(full=False)
+
+    # ── Case 1: AcroForm ────────────────────────────────────────────────────
+    if widgets:
+        boxes = []
+        for w in widgets:
+            r = w.rect
+            ftype: FieldType
+            if w.field_type in (fitz.PDF_WIDGET_TYPE_CHECKBOX, fitz.PDF_WIDGET_TYPE_RADIOBUTTON):
+                ftype = 'checkbox'
+            elif w.field_type == fitz.PDF_WIDGET_TYPE_SIGNATURE:
+                ftype = 'signature'
+            else:
+                ftype = 'text'
+            boxes.append({
+                'type': ftype,
+                'x': r.x0 / pw, 'y': (ph - r.y1) / ph,
+                'w': r.width  / pw, 'h': r.height / ph,
+                'label': w.field_name or '',
+                'source': 'acroform',
+            })
+        return {'source': 'acroform', 'boxes': boxes}
+
+    # ── Case 3: Image/scanned — no vector data to mine ────────────────────
+    if not drawings:
+        return {'source': 'needs_ml', 'boxes': []}
+
+    # ── Case 2: Flat vector PDF ────────────────────────────────────────────
+    text_spans = []
+    for block in page.get_text('dict', flags=fitz.TEXT_INHIBIT_SPACES).get('blocks', []):
+        for line in block.get('lines', []):
+            for span in line.get('spans', []):
+                t = span.get('text', '').strip()
+                if t:
+                    text_spans.append({'text': t, 'bbox': span['bbox']})
+
+    boxes = []
+    seen  = set()
+
+    for d in drawings:
+        r = d['rect']
+        w, h = r.width, r.height
+        if w < 1 or h < 1:
+            continue
+
+        key = (round(r.x0), round(r.y0))
+        if key in seen:
+            continue
+        seen.add(key)
+
+        x_frac = r.x0 / pw
+        y_frac = r.y0 / ph
+        w_frac = w / pw
+        h_frac = h / ph
+
+        # Small square → checkbox / radio
+        if abs(w - h) < w * 0.35 and 3 < w < 22:
+            label = _label_near(r.x0, r.y0, r.x1, r.y1, text_spans)
+            boxes.append({
+                'type': 'checkbox', 'source': 'vector',
+                'x': x_frac, 'y': y_frac, 'w': w_frac, 'h': h_frac,
+                'label': label,
+            })
+
+        # Thin horizontal line → text underline input
+        elif h < 2.5 and w > 20:
+            label = _label_near(r.x0, r.y0, r.x1, r.y1, text_spans)
+            pad   = min(14 / ph, 0.02)
+            boxes.append({
+                'type': 'text', 'source': 'vector_line',
+                'x': x_frac, 'y': max(0, y_frac - pad),
+                'w': w_frac, 'h': pad + h_frac + 1 / ph,
+                'label': label,
+            })
+
+        # Rectangular box wider than tall → text input field
+        elif w > h * 1.2 and h > 6 and w < pw * 0.95:
+            label = _label_near(r.x0, r.y0, r.x1, r.y1, text_spans)
+            boxes.append({
+                'type': 'text', 'source': 'vector_rect',
+                'x': x_frac, 'y': y_frac, 'w': w_frac, 'h': h_frac,
+                'label': label,
+            })
+
+    return {'source': 'vector', 'boxes': boxes}
+
+
+def detect_pdf(pdf_bytes: bytes) -> list[dict]:
+    doc = fitz.open(stream=pdf_bytes, filetype='pdf')
+    pages = []
+    for page_num, page in enumerate(doc):
+        result = detect_page(page)
+        result['page'] = page_num
+        result['width']  = page.rect.width
+        result['height'] = page.rect.height
+        pages.append(result)
+    doc.close()
+    return pages

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.115.0
+uvicorn==0.30.6
+python-multipart==0.0.9
+pymupdf==1.24.10