deploy-app

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11
+
+# Set working directory
+WORKDIR /code
+
+# Copy requirements and install
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Install system dependencies for OpenCV (YOLO usually needs this)
+RUN apt-get update && apt-get install -y libgl1-mesa-glx
+
+# Copy your source code
+COPY ./src /code/src
+
+# Create a directory for boxes if it doesn't exist (permissions fix)
+RUN mkdir -p /code/src/boxes && chmod 777 /code/src/boxes
+
+# Hugging Face Spaces expects the app to run on port 7860
+CMD ["uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "7860"]

src/app.py

@@ -0,0 +1,27 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+import gradio as gr  # <--- 1. Import Gradio
+
+from .storage.database import engine
+from .storage.models import Base
+from .routers.parse_router import router as parse_router
+from .ui.gradio_ui import gradio_app  # <--- 2. Import your UI object
+
+async def create_all_tables():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+        
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await create_all_tables()
+    yield
+
+app = FastAPI(lifespan=lifespan)
+
+# Include your API router
+app.include_router(parse_router, prefix="/parse", tags=["parse-image"])
+
+# 3. Mount Gradio UI
+# Now your supervisor can visit http://localhost:8000/ui
+#app = gr.mount_gradio_app(app, gradio_app, path="/ui")
+app = gr.mount_gradio_app(app, gradio_app, path="/ui", auth=("irandoc", "12345678"))

src/processing/parse_img.py

@@ -0,0 +1,64 @@
+from PIL import Image
+from huggingface_hub import hf_hub_download
+from doclayout_yolo import YOLOv10
+from ..storage.schemas import BaseBox
+import tempfile
+from pathlib import Path
+
+filepath = hf_hub_download(
+    repo_id="juliozhao/DocLayout-YOLO-DocStructBench",
+    filename="doclayout_yolo_docstructbench_imgsz1024.pt"
+)
+model = YOLOv10(filepath)
+
+
+def parse_img(
+    img: Image.Image,
+    device: str = "cpu",
+    box_directory: str = "src/boxes",
+):
+    """
+    Processes an image, runs detection, crops boxes, saves their images,
+    and returns a list of BaseBox objects with box metadata.
+    """
+    # Create box directory if it doesn't exist
+    Path(box_directory).mkdir(parents=True, exist_ok=True)
+
+    # Create temp file with delete=False so it stays on disk
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
+        img.save(temp_file.name, format="PNG")
+        img_path = temp_file.name
+
+    # Now model.predict can access the file
+    det_res = model.predict(
+        img_path,
+        imgsz=1024,
+        conf=0.2,
+        device=device
+    )
+
+    boxes_data = det_res[0].boxes.data
+    boxes_result = []
+    crop_image_list = []
+    for i, box_data in enumerate(boxes_data):
+        box_data = box_data.tolist()
+        crop = img.crop(tuple(box_data[:4]))
+        box_path = str(Path(box_directory) / f"box_{i}.png")
+        crop.save(box_path)
+        crop_image_list.append(crop)
+
+        box_info = BaseBox(
+            class_name=int(box_data[-1]),
+            x_min=float(box_data[0]),
+            y_min=float(box_data[1]),
+            x_max=float(box_data[2]),
+            y_max=float(box_data[3]),
+            confidence=float(box_data[-2]),
+            saved_img_path=box_path
+        )
+        boxes_result.append(box_info)
+
+    # Clean up temp file
+    Path(img_path).unlink(missing_ok=True)
+
+    return boxes_result, crop_image_list

src/routers/parse_router.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter, Depends, status, UploadFile, File
+from ..storage.schemas import BaseBox
+from ..storage.models import BoxesData
+from ..storage.database import get_session, engine
+from sqlalchemy.ext.asyncio import AsyncSession
+from PIL import Image
+import io
+from ..processing.parse_img import parse_img
+
+router = APIRouter()
+
+@router.post("/", response_model=list[BaseBox], status_code=status.HTTP_201_CREATED)
+async def parse_image(image_file: UploadFile = File(...), session: AsyncSession = Depends(get_session)):
+    contents = await image_file.read()
+    img = Image.open(io.BytesIO(contents))
+    
+    boxes_data, _ = parse_img(img)
+    
+    for box_data in boxes_data:
+        db_box = BoxesData(**box_data.model_dump())
+        session.add(db_box)
+    await session.commit()
+    
+    return boxes_data
+
+
+        
+
+    
+    
+    
+    

src/storage/database.py

@@ -0,0 +1,25 @@
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
+from pathlib import Path
+from collections.abc import AsyncGenerator
+# Create data directory if it doesn't exist
+DATA_DIR = Path("./data/database")
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+DATABASE_URL = "sqlite+aiosqlite:///./data/database/ocr_results.db"
+
+engine = create_async_engine(
+    DATABASE_URL,
+    echo=False
+)
+
+async_session_maker = async_sessionmaker(
+    bind=engine,
+    class_=AsyncSession,
+    expire_on_commit=False
+)
+
+
+async def get_session() -> AsyncGenerator[AsyncSession]:
+    """Dependency to get async database session."""
+    async with async_session_maker() as session:
+        yield session

src/storage/models.py

@@ -0,0 +1,23 @@
+from sqlalchemy import Integer, Float, Text
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+class Base(DeclarativeBase):
+    pass
+
+class BoxesData(Base):
+    __tablename__= "croped_boxes_metadata"
+    
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    class_name: Mapped[int] = mapped_column(Integer)
+  
+    x_min: Mapped[float] = mapped_column(Float)
+    y_min: Mapped[float] = mapped_column(Float)
+    x_max: Mapped[float] = mapped_column(Float)
+    y_max: Mapped[float] = mapped_column(Float)
+    
+    confidence: Mapped[float] = mapped_column(Float)
+    saved_img_path: Mapped[str] = mapped_column(Text)
+    
+    
+    
+    

src/storage/schemas.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, Field
+
+class BaseBox(BaseModel):
+    class_name: int = Field(..., description="Integers that each show type of box")
+    x_min: float = Field(..., description="X-coordinate of the top-left corner.")
+    y_min: float = Field(..., description="Y-coordinate of the top-left corner.")
+    x_max: float = Field(..., description="X-coordinate of the bottom-right corner.")
+    y_max: float = Field(..., description="Y-coordinate of the bottom-right corner.")
+    confidence: float
+    saved_img_path: str
+    
+    class Config:
+        from_attributes = True

src/ui/gradio_ui.py

@@ -0,0 +1,18 @@
+import gradio as gr
+
+from ..processing.parse_img import parse_img
+
+def ui_predict_fn(image):
+    # Wrapper to format data specifically for Gradio Gallery
+    _, gallery_items = parse_img(image)
+    return gallery_items
+
+# Define the Interface/Blocks
+with gr.Blocks(title="DocLayout Parser") as gradio_app:
+    gr.Markdown("## Supervisor Dashboard")
+    with gr.Row():
+        input_img = gr.Image(type="pil", label="Upload Document")
+        output_gal = gr.Gallery(label="Parsed Regions")
+    
+    btn = gr.Button("Run Analysis", variant="primary")
+    btn.click(fn=ui_predict_fn, inputs=input_img, outputs=output_gal)