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

Introduction

FastAPIest un framework web moderne et haute performance pour créer des API 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. Dans la suite de cet article, nous aborderons également les points suivantsIronPDFun package Python de génération de PDF deIron 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 Pydantic pour les parties 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 des documents API interactifs 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 soutien pour l'auto-complétion de code et la vérification de types dans des éditeurs comme VS Code, rendant le développement plus rapide et réduisant les erreurs.

5. Basé sur les normes : Il est basé sur(et entièrement compatible avec)les normes ouvertes pour les API : OpenAPI et JSON Schema.

Installation

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

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}

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}

Pour exécuter l'application, utilisez Uvicorn :

uvicorn main:app --reload

uvicorn main:app --reload

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épendances : FastAPI propose un système d'injection de dépendances 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 avoir renvoyé une réponse, utile pour des tâches telles que 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 inclut des outils pour gérer la sécurité, y compris OAuth2, les jetons JWT, et plus encore.

5. Intégration de 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 un CRUD simple(Créer, lire, mettre à jour, supprimer)API pour la gestion des 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

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

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"}

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"}

Présentation d'IronPDF

IronPDFest une puissante bibliothèque Python conçue pour créer, éditer et signer des PDF à 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

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

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

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éfinir 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.3. Gestionnaires de routes de base : `read_root()`: Répond avec un simple message JSON indiquant "Hello IronPDF" lors de l'accès à l'URL racine(`/`). **`read_item()Accepte un paramètre de chemin `item_id` et un paramètre de requête `q` optionnel. Renvoie une réponse JSON avec ces paramètres de fonction.

3. Route de génération de PDF(`/pdf`): `get_pdf()I'm sorry, but your request seems incomplete. Could you please provide more text for translation?

   • Cette fonction asynchrone gère les requêtes GET vers le point de terminaison `/pdf` avec un paramètre de requête optionnel nommé(greet1 et greet2).
   • Construit une chaîne HTML(\N- Contenu)qui inclut : Un en-tête indiquant l'origine et le but du document. Un paragraphe démontrant la génération de PDF à l'aide des entrées utilisateur.(greet1 et greet2). Utilise `ChromePdfRenderer()` depuis IronPDF pour rendre le contenu HTML en PDF(`pdf = renderer.RenderHtmlAsPdf(contenu)`).
   • Enregistre le PDF généré sous "fastapi.pdf"(`pdf.SaveAs("fastapi.pdf")`).5. Servir le PDF :
   • Configure les en-têtes de réponse pour spécifier que le PDF doit être affiché 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 media approprié("application/pdf").
   • Renvoie l'objet `FileResponse`, qui déclenche le téléchargement du document PDF lorsque le point de terminaison `/pdf` est accédé.

   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 pour Python offre un service deessai gratuitclé de licence pour permettre aux utilisateurs de tester 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"

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

Conclusion

FastAPIest 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.

IronPDFest 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 de HTML en PDF, la création de formulaires interactifs, la manipulation de PDF.(fusion, scission), et extraction de texte. Idéal pour générer des PDF dynamiques facilement et les intégrer dans diverses applications Python.