FastAPI Python (Comment cela fonctionne pour les développeurs)

Introduction

FastAPI est un framework web moderne et haute performance pour construire des APIs avec Python. Il est conçu pour être facile à utiliser et à apprendre tout en offrant des fonctionnalités puissantes telles que la validation automatique, la sérialisation et la documentation interactive automatique de l'API. De plus, il fonctionne avec n'importe quel moteur de template et vous permet d'utiliser n'importe quelle configuration de template par défaut nécessaire pour votre projet.

Plongeons dans les détails de FastAPI, ses fonctionnalités et comment l'utiliser efficacement. Plus tard dans cet article, nous examinerons également IronPDF, un package Python de génération de PDF de Iron Software.

Principales fonctionnalités de FastAPI

1. Haute performance : FastAPI est l'un des frameworks Python les plus rapides disponibles, comparable à Node.js et Go, grâce à son utilisation de Starlette pour les parties web et de Pydantic pour les parties de données.

2. Facilité d'utilisation : Il est conçu pour être intuitif et réduire le temps passé à lire la documentation. Le framework utilise des annotations de type standard Python pour la validation et la sérialisation des données.

3. Documentation interactive automatique : FastAPI génère automatiquement une documentation API interactive en utilisant OpenAPI et JSON Schema, accessible via /docs (Swagger UI) et /redoc (ReDoc) et la mise à niveau interactive des documents API signifie que cette documentation se met à jour automatiquement. La mise à niveau des documents API alternative le reflétera également.

4. Support de l'éditeur : Excellent support pour l'autocomplétion de code et la vérification de type dans des éditeurs comme VS Code, rendant le développement plus rapide et réduisant les erreurs.

5. Basé sur les standards : Il est basé sur (et entièrement compatible avec) les standards ouverts pour les APIs : OpenAPI et JSON Schema.

Installation

Vous pouvez installer FastAPI et Uvicorn (un serveur ASGI) en utilisant pip :

pip install fastapi
pip install "uvicorn[standard]"

pip install fastapi
pip install "uvicorn[standard]"

Création de votre première application FastAPI

Voici un exemple simple pour commencer avec FastAPI et exposer des données Python à travers une interface utilisateur :

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "World"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

py

Pour exécuter l'application, utilisez Uvicorn :

uvicorn main:app --reload

py

Cette commande lancera un serveur de développement et rechargera automatiquement pour les modifications de code. Vous pouvez accéder à la documentation interactive de l'API à l'adresse http://127.0.0.1:8000/docs.

Fonctionnalités avancées

FastAPI prend en charge un large éventail de fonctionnalités avancées, le rendant adapté aux applications complexes :

1. Injection de dépendance : FastAPI propose un système d'injection de dépendance puissant qui vous permet de gérer les dépendances de manière propre et efficace.

2. Tâches en arrière-plan : Vous pouvez définir des tâches en arrière-plan à exécuter après le retour d'une réponse, utile pour des tâches comme l'envoi d'e-mails ou le traitement de données.

3. WebSockets : FastAPI prend en charge les WebSockets, permettant une communication en temps réel entre le client et le serveur.

4. Sécurité : FastAPI comprend des outils pour gérer la sécurité, notamment OAuth2, des jetons JWT, et plus encore.

5. Intégration de la base de données : FastAPI peut être facilement intégré avec des bases de données en utilisant des bibliothèques comme SQLAlchemy ou Tortoise-ORM.

Exemple : Création d'une API CRUD

Construisons une API CRUD (Create, Read, Update, Delete) simple pour gérer les articles.

1. Définir le modèle de données :

from pydantic import BaseModel
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

py

1. Créer l'application FastAPI :

from fastapi import FastAPI, HTTPException
app = FastAPI()
items = {}
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item
@app.get("/items/{item_id}") # optional str query parameter
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]
@app.put("/items/{item_id}") # with path parameters
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

py

Présentation d'IronPDF

IronPDF est une puissante bibliothèque Python conçue pour créer, éditer et signer des PDFs à partir de HTML, CSS, images et JavaScript. Il offre des performances de niveau commercial avec une faible empreinte mémoire. Les principales caractéristiques sont les suivantes :

Conversion de HTML en PDF

Convertissez des fichiers HTML, des chaînes HTML et des URL en PDF. Par exemple, rendre une page web sous forme de PDF à l'aide du moteur de rendu PDF de Chrome.

Support multiplateforme

Compatible avec diverses plateformes .NET, notamment .NET Core, .NET Standard et .NET Framework. Il est compatible avec Windows, Linux et macOS.

Édition et signature

Définissez des propriétés, renforcez la sécurité à l'aide de mots de passe et d'autorisations, et appliquez des signatures numériques à vos PDF.

Modèles de page et paramètres

Personnalisez les PDF avec des en-têtes, des pieds de page, des numéros de page et des marges réglables. Prend en charge les mises en page réactives et les formats de papier personnalisés.

Respect des normes

Respecter les normes PDF telles que PDF/A et PDF/UA. Prend en charge le codage des caractères UTF-8 et gère les ressources telles que les images, les feuilles de style CSS et les polices.

Générez des documents PDF à l'aide d'IronPDF et de FastAPI

pip install fastapi
pip install ironPDF

pip install fastapi
pip install ironPDF

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
app = FastAPI()
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}
@app.get("/items/{item_id}") # with query parameters
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}
@app.get("/pdf")
async def get_pdf(greet1: str = None,greet2: str = None):
    renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
    content = "<h1>Document Generated using IronPDF with fastapi GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs"+"</p>"
    content += "<p>"+f"Greetings from: {greet1}"+"</p>"
    content += "<p>"+f"And Greetings from: {greet2}"+"</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
    pdf.SaveAs("fastapi.pdf") 
    # To view the file in the browser, use "inline" for the media_type
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }  
    # Create a FileResponse object with the file path, media type and headers
    response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)
    # Return the FileResponse object
    return response

py

Explication du code

Cet extrait de code démontre l'intégration de IronPDF avec FastAPI pour générer dynamiquement des documents PDF basés sur les saisies des utilisateurs et les servir en tant que réponse téléchargeable.

1. Définition de la clé de licence : Applique la clé de licence IronPDF pour activer ses fonctionnalités.

2. Initialisation de FastAPI : Initialise une instance FastAPI (`app`) pour gérer les requêtes HTTP. Gestionnaires de routes de base : `read_root()` : Répond avec un message JSON simple indiquant "Hello IronPDF" lors de l'accès à l'URL racine (`/`). `read_item()` : Accepte un paramètre de chemin `item_idet un paramètre de requête optionnel \q`. Renvoie une réponse JSON avec ces paramètres de fonction.

3. Route de Génération de PDF (`/pdf`) : `get_pdf()`:

   • Cette fonction asynchrone gère les requêtes GET vers l'endpoint `/pdf` avec un paramètre de requête optionnel nommé (`greet1` et `greet2`).
   • Construit une chaîne HTML (`content`) qui inclut : Un en-tête indiquant l'origine et le but du document. Un paragraphe démontrant la génération de PDF en utilisant les entrées utilisateur (`greet1` et `greet2`). Utilise `ChromePdfRenderer()` d'IronPDF pour convertir le contenu HTML en PDF (`pdf = renderer.RenderHtmlAsPdf(content)`).
   • Enregistre le PDF généré sous le nom "fastapi.pdf" (`pdf.SaveAs("fastapi.pdf")`).5. Service du PDF :
   • Configure les en-têtes de réponse pour spécifier que le PDF doit être visualisé en ligne dans le navigateur (`"Content-Disposition": "inline; filename=sample.pdf"`).
   • Crée un objet `FileResponse` pointant vers le fichier PDF généré avec le type de média approprié (`"application/pdf"`).
   • Renvoie l'objet `FileResponse`, qui déclenche le téléchargement du document PDF lorsque le point d'accès `/pdf` est consulté.

   Cet extrait de code illustre comment IronPDF peut être intégré de manière transparente avec FastAPI pour générer et servir dynamiquement des documents PDF en fonction des saisies de l'utilisateur. Il démontre la capacité de convertir du contenu HTML en PDF, ce qui le rend adapté aux applications nécessitant la génération et la livraison de documents à la volée via HTTP.

Sortie

Ci-dessous est affichée la sortie Swagger générée à partir des APIs

PDF

Licence d'IronPDF

IronPDF fonctionne avec la clé de licence pour Python. IronPDF for Python offre une clé de licence d'essai gratuit pour permettre aux utilisateurs de découvrir les fonctionnalités avant l'achat.

Placez la clé de licence au début du script avant d'utiliser le package IronPDF :

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"

py

Conclusion

FastAPI est un framework puissant et facile à utiliser pour créer des API en Python. FastAPI possède des performances élevées, une documentation automatique et des fonctionnalités avancées en font un excellent choix pour les débutants comme pour les développeurs expérimentés. Que vous construisiez une API simple ou une application web complexe, FastAPI fournit les outils dont vous avez besoin pour réussir.

IronPDF est une bibliothèque Python robuste pour créer, manipuler et rendre des documents PDF à partir de contenu HTML. Il offre des fonctionnalités telles que la conversion HTML en PDF, la création de formulaires interactifs, la manipulation de PDF (fusion, division) et l'extraction de texte. Idéal pour générer des PDF dynamiques facilement et les intégrer dans diverses applications Python.