Implementace prevodu HTML na PDF

Sluzba prijme adresu HTML dokumentu nebo HTML v tele requestu a vrati PDF.
Navrzena pro dokumenty o stovkach az tisicich stranek.

Rendering:
- WeasyPrint jako vychozi engine, spravne CSS Paged Media, nizka pametova
  narocnost, bez JavaScriptu
- Chromium pres Playwright pro dokumenty dokreslovane skripty
- rezim auto s detekci skriptu a fallbackem pri selhani WeasyPrintu

Velke dokumenty:
- deleni na casti na strukturalnich hranicich, rez nikdy uvnitr tabulky
  nebo odstavce
- dvoupruchodovy render obsahu se skutecnymi cisly stranek, pozice nadpisu
  se ctou z kotev hlasenych u kazde stranky
- cislovani stranek bud pres CSS countery, nebo pres cislovaci vrstvu
  nastampovanou na hotove PDF, rozmer stranky se cte z vysledneho souboru
- Chromium se restartuje po N jobech, nikdy vsak behem beziciho renderu

API:
- POST /convert synchronne, POST /jobs asynchronne se sledovanim stavu,
  stahovanim vysledku, rusenim a volitelnym callbackem
- GET /health s overenim dostupnosti obou enginu a stavem fronty
- OpenAPI respektuje prefix reverse proxy pres root_path

Bezpecnost a provoz:
- SSRF kontrola po DNS resolvu, na kazdem presmerovani a u vsech pozadavku
  prohlizece
- nedostupne assety render nezastavi, ale hlasi se v odpovedi i v logu
- fronta s omezenym poctem workeru, rozpracovane joby se pri ukonceni
  oznaci jako failed, nezmizi potichu
- strukturovane JSON logovani s job_id
- vsechny limity vypnute ve vychozim stavu

Dockerfile je dvoufazovy, obsahuje zavislosti WeasyPrintu, Chromium
a fonty s ceskou diakritikou.

Autentizace zamerne neni implementovana, zpusob predavani neni domluveny.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
JiriUhlir
2026-08-27 14:50:10 +02:00
co-authored by Claude Opus 5
parent e3cc8f418b
commit 156289fe2d
48 changed files with 4043 additions and 24 deletions
View File
+78
View File
@@ -0,0 +1,78 @@
"""Synchronous conversion.
Suitable for smaller documents. Anything that does not finish within
SYNC_TIMEOUT_SECONDS is cancelled and the caller is pointed at /jobs.
"""
from __future__ import annotations
import asyncio
import logging
from fastapi import APIRouter, Response
from fastapi.responses import FileResponse
from starlette.background import BackgroundTask
from ..deps import get_container
from ..errors import ConversionError, SyncTooLongError, error_from_code
from ..models import ConvertRequest
logger = logging.getLogger(__name__)
router = APIRouter(tags=["konverze"])
@router.post(
"/convert",
summary="Synchronni prevod HTML na PDF",
response_class=Response,
responses={
200: {"content": {"application/pdf": {}}, "description": "Hotove PDF."},
413: {"description": "Konverze trvala dele nez limit, pouzijte POST /jobs."},
},
)
async def convert(request: ConvertRequest):
container = get_container()
settings = container.settings
manager = container.jobs
job = manager.submit(request)
try:
await asyncio.wait_for(job.done.wait(), timeout=settings.sync_timeout_seconds)
except asyncio.TimeoutError as exc:
manager.cancel(job.id)
logger.warning(
"Synchronous conversion exceeded its budget",
extra={"job_id": job.id, "limit_seconds": settings.sync_timeout_seconds},
)
raise SyncTooLongError(
"Konverze presahla limit pro synchronni pozadavek. Pouzijte asynchronni endpoint POST /jobs.",
{"limit_seconds": settings.sync_timeout_seconds},
) from exc
if job.state.status != "done":
error = job.state.error
if error is not None:
raise error_from_code(error.error_code, error.message, error.detail)
raise ConversionError("Konverze skoncila ve stavu " + job.state.status + ".")
path = container.storage.result_path(job.id)
filename = request.filename or "dokument.pdf"
headers = {
"X-Page-Count": str(job.state.page_count or 0),
"X-Engine-Used": job.state.engine_used or "",
}
if job.state.missing_assets:
headers["X-Missing-Assets"] = str(len(job.state.missing_assets))
if job.state.warnings:
headers["X-Warnings"] = str(len(job.state.warnings))
return FileResponse(
path,
media_type="application/pdf",
filename=filename,
headers=headers,
background=BackgroundTask(container.storage.discard, job.id),
)
+47
View File
@@ -0,0 +1,47 @@
"""Health and version endpoints required by AppFactory."""
from __future__ import annotations
import logging
from fastapi import APIRouter
from ..deps import get_container
from ..models import HealthResponse
logger = logging.getLogger(__name__)
router = APIRouter(tags=["service"])
@router.get("/health", response_model=HealthResponse, summary="Stav sluzby")
async def health() -> HealthResponse:
container = get_container()
engines = {}
for name, engine in container.engines.items():
try:
engines[name] = await engine.available()
except Exception as exc:
logger.error("Engine availability check failed", extra={"engine": name}, exc_info=exc)
engines[name] = False
status = "ok" if any(engines.values()) else "degraded"
return HealthResponse(
status=status,
app=container.settings.app_name,
version=container.settings.app_version,
engines=engines,
queue=container.jobs.stats(),
)
@router.get("/version", summary="Verze a zakladni informace o sluzbe")
async def version() -> dict:
settings = get_container().settings
return {
"app": settings.app_name,
"version": settings.app_version,
"language": "python",
"root_path": settings.root_path,
}
+90
View File
@@ -0,0 +1,90 @@
"""Asynchronous conversion. This is the path for large documents."""
from __future__ import annotations
import logging
from fastapi import APIRouter, Response, status
from fastapi.responses import FileResponse
from ..deps import get_container
from ..errors import ConversionError, JobNotFoundError
from ..models import ConvertRequest, JobAccepted, JobState
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/jobs", tags=["joby"])
def _result_url(job_id: str) -> str:
root = get_container().settings.root_path.rstrip("/")
return f"{root}/jobs/{job_id}/result"
@router.post(
"",
response_model=JobAccepted,
status_code=status.HTTP_202_ACCEPTED,
summary="Zaradi konverzi do fronty",
)
async def create_job(request: ConvertRequest) -> JobAccepted:
job = get_container().jobs.submit(request)
return JobAccepted(
job_id=job.id,
status=job.state.status,
created_at=job.state.created_at,
result_url=_result_url(job.id),
)
@router.get("/{job_id}", response_model=JobState, summary="Stav jobu")
async def job_state(job_id: str) -> JobState:
job = get_container().jobs.get(job_id)
state = job.state.model_copy()
if state.status == "done":
state.result_url = _result_url(job_id)
return state
@router.get(
"/{job_id}/result",
summary="Stahne hotove PDF",
response_class=Response,
responses={
200: {"content": {"application/pdf": {}}, "description": "Hotove PDF."},
404: {"description": "Job neexistuje nebo uz expiroval."},
409: {"description": "Job jeste nedobehl nebo skoncil chybou."},
},
)
async def job_result(job_id: str):
container = get_container()
job = container.jobs.get(job_id)
if job.state.status != "done":
error = ConversionError(
f"Vysledek neni k dispozici, job je ve stavu {job.state.status}.",
{"status": job.state.status},
)
error.error_code = "result_not_ready"
error.status_code = 409
raise error
path = container.storage.result_path(job_id)
if not path.exists():
raise JobNotFoundError("Soubor s vysledkem uz neexistuje, job pravdepodobne expiroval.")
filename = job.request.filename or "dokument.pdf"
return FileResponse(
path,
media_type="application/pdf",
filename=filename,
headers={
"X-Page-Count": str(job.state.page_count or 0),
"X-Engine-Used": job.state.engine_used or "",
},
)
@router.delete("/{job_id}", response_model=JobState, summary="Zrusi job nebo smaze jeho vysledek")
async def delete_job(job_id: str) -> JobState:
return get_container().jobs.cancel(job_id).state