Jerry PDF Service - Custom OCR Microservice

from fastapi import FastAPI, UploadFile, File, Security, HTTPException
from fastapi.security import APIKeyHeader
from pdf2image import convert_from_bytes
import hashlib, base64, sqlite3

# API Security Setup
API_KEY_NAME = "X-API-Key"
api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
SECRET_API_KEY = os.environ.get("API_KEY")

app = FastAPI(
    title="PDF Processing API",
    dependencies=[Security(get_api_key)]  # Global protection
)

@app.post("/process_pdf")
async def process_pdf(file: UploadFile = File(...)):
    pdf_bytes = await file.read()
    images = convert_from_bytes(pdf_bytes, dpi=150, fmt="jpeg")
    
    results = []
    for i, img in enumerate(images):
        # Convert to bytes and generate hash
        img_bytes_io = io.BytesIO()
        img.save(img_bytes_io, format="JPEG", quality=85)
        img_bytes = img_bytes_io.getvalue()
        page_hash = hashlib.sha256(img_bytes).hexdigest()
        
        # Check cache for existing translation
        cached_result = check_cache(page_hash)
        
        page_data = {
            "page_number": i + 1,
            "page_hash": page_hash,
            "cached": bool(cached_result),
            "translation": cached_result[0] if cached_result else None,
            "image_base64": None if cached_result else base64.b64encode(img_bytes).decode()
        }
        results.append(page_data)
    
    return {"pages": results}

# docker-compose.dev.yml
version: '3.7'

services:
  pdf-service:
    build:
      context: .
    container_name: jerry-pdf-service-dev
    restart: unless-stopped
    ports:
      - "8001:8000"  # Expose on homelab network
    environment:
      - ENVIRONMENT=${ENVIRONMENT}
      - API_KEY=${API_KEY}
    volumes:
      - ./data:/app/data          # Persistent database
      - ./main.py:/app/main.py    # Hot reload capability
    command: uvicorn main:app --host 0.0.0.0 --port 8000 --reload

# SQLite caching with SHA256 optimization
def setup_database():
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS page_translations (
            page_hash TEXT PRIMARY KEY,           -- SHA256 of image content
            translation TEXT,                     -- Cached translation result
            translated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    """)
    conn.commit()
    conn.close()

@app.post("/cache_translation")
async def cache_translation(entry: CacheEntry):
    """Store translation result for future identical pages"""
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute(
        "INSERT OR REPLACE INTO page_translations (page_hash, translation) VALUES (?, ?)",
        (entry.page_hash, entry.translation)
    )
    conn.commit()
    conn.close()
    return {"status": "success", "page_hash": entry.page_hash}

@app.post("/check_cache_by_hash")
async def check_cache_by_hash(item: HashCheck):
    """N8N endpoint for checking cached translations"""
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute("SELECT translation FROM page_translations WHERE page_hash = ?", (item.page_hash,))
    cached_result = cursor.fetchone()
    conn.close()
    
    return {
        "cached": bool(cached_result),
        "translation": cached_result[0] if cached_result else None,
        "page_hash": item.page_hash
    }