ml
ca85530b5a
build / build (push) Successful in 2m57s
Preprocessing now tries progressively heavier variants per receipt (plain -> high-pass -> edge-enhance -> both), stopping as soon as a cheap LLM-free arithmetic check on the OCR text looks plausible, so the extra processing only applies to receipts that need it. A flat version of the same heavier processing regressed the full batch by helping hard receipts but hurting easy ones; the adaptive version improves date-matching 37/52 -> 40/52 with no regression (see testing/2026_10_04_gimp_highpass_nlfilter_experiment.md). Also adds test_ocr.sh and test_single.sh for checking a single receipt's OCR text or full pipeline result without a batch run.
123 lines
4.2 KiB
Python
123 lines
4.2 KiB
Python
#!/usr/bin/env python3
|
|
"""HTTP API that serves the pipeline (preprocess -> ocr -> structure) to
|
|
the Android app. Runs the same in-process functions the numbered host
|
|
scripts drive via `docker run` per stage, but skips the per-stage
|
|
container start-up since a live server has no need for that
|
|
inspectability - the host scripts remain the way to inspect each stage
|
|
independently during pipeline development.
|
|
|
|
Jobs are processed asynchronously so the app can show real per-stage
|
|
progress: POST /jobs returns immediately with a job id; GET /jobs/{id}
|
|
reports which of preprocessing/ocr/extracting is currently running, and
|
|
the final result once done. Job state lives in memory only - this is a
|
|
personal, LAN-only, single-instance server with no need for persistence
|
|
here (the Android app is the system of record for confirmed receipts).
|
|
"""
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
import uuid
|
|
|
|
import requests
|
|
from fastapi import FastAPI, HTTPException, UploadFile
|
|
from fastapi.responses import JSONResponse
|
|
|
|
from adaptive import preprocess_and_ocr_adaptive
|
|
from extract import structure
|
|
|
|
OLLAMA_BASE_URL = os.environ.get("OLLAMA_BASE_URL", "http://127.0.0.1:11434")
|
|
OLLAMA_MODEL = os.environ.get("OLLAMA_MODEL", "qwen2.5:3b")
|
|
|
|
app = FastAPI(title="fuelish")
|
|
|
|
_jobs: dict[str, dict] = {}
|
|
_jobs_lock = threading.Lock()
|
|
|
|
|
|
def _set_job(job_id: str, **fields) -> None:
|
|
with _jobs_lock:
|
|
_jobs[job_id].update(fields)
|
|
|
|
|
|
def _ensure_model_pulled() -> None:
|
|
"""Best-effort: wait for Ollama to come up (compose starts `api` and
|
|
`ollama` together, with no ordering guarantee beyond container start)
|
|
and pull OLLAMA_MODEL if it isn't already present, so a bare `docker
|
|
compose up` is enough without a manual `ollama pull` step. Runs in a
|
|
background thread - jobs submitted before this finishes will simply
|
|
fail with a clear error from Ollama."""
|
|
tags = None
|
|
for _ in range(60):
|
|
try:
|
|
tags = requests.get(f"{OLLAMA_BASE_URL}/api/tags", timeout=5).json()
|
|
break
|
|
except requests.RequestException:
|
|
time.sleep(2)
|
|
if tags is None:
|
|
return
|
|
|
|
have = {m["name"] for m in tags.get("models", [])}
|
|
if OLLAMA_MODEL in have or any(m.startswith(OLLAMA_MODEL + ":") for m in have):
|
|
return
|
|
try:
|
|
requests.post(
|
|
f"{OLLAMA_BASE_URL}/api/pull",
|
|
json={"name": OLLAMA_MODEL},
|
|
timeout=1800,
|
|
)
|
|
except requests.RequestException:
|
|
pass
|
|
|
|
|
|
@app.on_event("startup")
|
|
def _on_startup() -> None:
|
|
threading.Thread(target=_ensure_model_pulled, daemon=True).start()
|
|
|
|
|
|
@app.get("/health")
|
|
def health() -> dict:
|
|
return {"status": "ok"}
|
|
|
|
|
|
def _process_job(job_id: str, image_path: str, scratch_dir: str) -> None:
|
|
try:
|
|
_set_job(job_id, status="preprocessing")
|
|
adaptive_result = preprocess_and_ocr_adaptive(image_path, scratch_dir)
|
|
|
|
_set_job(job_id, status="extracting")
|
|
result = structure(adaptive_result["ocr_text"])
|
|
|
|
_set_job(job_id, status="done", result=result)
|
|
except Exception as exc: # noqa: BLE001 - reported to the client, not swallowed
|
|
_set_job(job_id, status="error", error=str(exc))
|
|
finally:
|
|
shutil.rmtree(scratch_dir, ignore_errors=True)
|
|
|
|
|
|
@app.post("/jobs", status_code=201)
|
|
async def create_job(image: UploadFile) -> JSONResponse:
|
|
job_id = uuid.uuid4().hex
|
|
scratch_dir = tempfile.mkdtemp(prefix=f"fuelish-{job_id}-")
|
|
image_path = os.path.join(scratch_dir, "upload" + os.path.splitext(image.filename or "")[1])
|
|
with open(image_path, "wb") as f:
|
|
f.write(await image.read())
|
|
|
|
with _jobs_lock:
|
|
_jobs[job_id] = {"status": "queued", "result": None, "error": None, "_created": time.time()}
|
|
|
|
thread = threading.Thread(target=_process_job, args=(job_id, image_path, scratch_dir), daemon=True)
|
|
thread.start()
|
|
|
|
return JSONResponse({"job_id": job_id}, status_code=201)
|
|
|
|
|
|
@app.get("/jobs/{job_id}")
|
|
def get_job(job_id: str) -> dict:
|
|
with _jobs_lock:
|
|
job = _jobs.get(job_id)
|
|
if job is None:
|
|
raise HTTPException(status_code=404, detail="job not found")
|
|
return {"status": job["status"], "result": job["result"], "error": job["error"]}
|