Créez une API pour convertir des fichiers PDF en images TIF avec FastAPI et Docker

introduction

J'ai entendu de mon patron que l'API rapide semble être bonne, alors je l'ai touchée. C'est ennuyeux de simplement faire une demande GET et de renvoyer des caractères, j'ai donc créé une API pour convertir un fichier PDF en image TIF.

Qu'est-ce que FastAPI

FastAPI est le framework Web de Python, similaire à Flask.

Environnement de développement

• Windows10 Pro
• Docker for Windows

la mise en oeuvre

Structure du répertoire

root
├─app.py
├─Dockerfile
├─requirements.txt
└─test.pdf

Dockerfile

Dockerfile

FROM python:3.8

#Installez poppler requis pour la conversion PDF
RUN apt-get update && \
    apt-get install -y poppler-utils

#Installer le module Python
COPY requirements.txt .
RUN pip install --upgrade pip && \
    pip install -r requirements.txt && \
    rm requirements.txt

#Créez un dossier pour enregistrer temporairement le fichier converti
RUN rm -rf /app && \
    mkdir -p /app/data/

#Placez le programme
COPY app.py /app/app.py

EXPOSE 8000
WORKDIR /app
CMD ["uvicorn", "app:api", "--host", "0.0.0.0", "--port", "8000"]

Cette fois, j'ai utilisé l'image de python: 3.8, mais tout va bien tant que Python fonctionne et que poppler peut être installé.

requirements.txt

requirements.txt:requirements.txt

fastapi
uvicorn
python-multipart
pdf2image

fastapi et ʻuvicornsont requis lors de l'utilisation de FastAPI Nécessitepython-multipartlors du téléchargement de fichiers Nécessitepdf2image` pour convertir un fichier PDF en image

app.py

app.py

import os
from base64 import b64encode

import uvicorn
from fastapi import FastAPI, File, UploadFile
from pdf2image import convert_from_bytes
from PIL import Image

api = FastAPI()


@api.post("/")
async def post(file: UploadFile = File(...)):
    pdf_file = await file.read()
    tif_file = convert(pdf_file)
    return tif_file


def convert(pdf_file):
    output_folder = "./data"
    file_name = "temporary"
    output_file_path = f"{output_folder}/{file_name}.tif"

    #Convertissez toutes les pages de PDF en jpg et enregistrez-les
    image_path = convert_from_bytes(
        pdf_file=pdf_file,
        thread_count=5,
        fmt="jpg",
        output_folder=output_folder,
        output_file=file_name,
        paths_only=True,
    )

    #Charger toutes les images jpg
    images = [Image.open(image) for image in image_path]

    #Convertissez toutes les images jpg en une seule image TIF et enregistrez
    images[0].save(
        output_file_path, format="TIFF", save_all=True, append_images=images[1:],
    )

    #Lire toutes les images jpg et encoder avec base64
    with open(output_file_path, "rb") as f:
        tif_file = b64encode(f.read())

    #Supprime toutes les images enregistrées et renvoie un binaire d'images TIFF
    for image in image_path:
        os.remove(image)
    os.remove(output_file_path)
    return tif_file


if __name__ == "__main__":
    uvicorn.run(api)

Notez que si vous ne définissez pas path_only = True dans convert_from_bytes, cela consommera beaucoup de mémoire.

Courir

Démarrer Docker

1. Build

   docker build -t fastapi .
   

2. Run

   docker run --rm -it -p 8000:8000 fastapi
   

Demande d'API

 > curl -X POST -F 'file=@./test.pdf' http://localhost:8000 | base64 -di > ./test.tif
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  100  206M  100  206M  100  309k  27.0M  41409  0:00:07  0:00:07 --:--:-- 47.2M

Il sera encodé en base64 et retourné, vous devez donc le décoder et l'écrire en base64.

Résumé

J'avais besoin de python-multipart pour télécharger le fichier, et j'avais quelques pierres d'achoppement, mais j'ai trouvé l'API Fast très facile à écrire.