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

pip install fastapi
pip install "uvicorn[standard]"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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}

from fastapi import FastAPI app = FastAPI() app.get("/") def read_root(): Return
If True Then
	"Hello": "World"
End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@app.@get("/items/{item_id}") # @with query parameters def read_item(item_id: int, q: str = None): Return
'{
''INSTANT VB TODO TASK: The following line uses invalid syntax:
''	"item_id": item_id, "q": q}

Pour exécuter l'application, utilisez Uvicorn :

uvicorn main:app --reload

uvicorn main:app --reload

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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"}

404, detail="Item not found"
status_code=404, detail
404, detail="Item not found"
status_code=404, detail
404, detail="Item not found"
status_code=404, detail
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: 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
item Return item app.get("/items/{item_id}") # [optional] str query parameter def read_item(item_id:= Integer): if item_id [not] in items: raise HTTPException(status_code) Return items(item_id) app.put("/items/{item_id}") # [with] path parameters def update_item(item_id: Integer, item: Item): if item_id [not] in items: raise HTTPException(status_code) items(item_id) = item Return item app.delete("/items/{item_id}") def delete_item(item_id: Integer): if item_id [not] in items: raise HTTPException(status_code) del items(item_id) Return
If True Then
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: 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) 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) items[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:= Integer): if item_id [not] in items: raise HTTPException(status_code) Return items(item_id) app.put("/items/{item_id}") # [with] path parameters def update_item(item_id: Integer, item: Item): if item_id [not] in items: raise HTTPException(status_code) items(item_id)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI, HTTPException app = FastAPI() items = {} @app.post("/items/") def create_item(item: Item): item_id = len(items) + 1 items[item_id]
{} app.post("/items/") def create_item(item:= Item): item_id = len(items) + 1 items(item_id)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI, HTTPException app = FastAPI() items = {} @app.post("/items/") def create_item(item: Item): item_id
FastAPI() items = {} app.post("/items/") def create_item(item:= Item): item_id
from fastapi import FastAPI, HTTPException app = FastAPI() items
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'	"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

pip install fastapi
pip install ironPDF

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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

#Apply your license key
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: from fastapi import FastAPI from fastapi.responses import FileResponse from ironpdf import * License.LicenseKey = "key" app = FastAPI() @app.get("/") def read_root(): return
"key" app = FastAPI() app.get("/") def read_root(): Return
If True Then
From fastapi import FastAPI From fastapi.responses import FileResponse From ironpdf import * License.LicenseKey = "key" app
	"Hello": "IronPDF"
End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@app.@get("/items/{item_id}") # @with query parameters def read_item(item_id: int, q: str = None): Return
'{
'	"item_id": item_id, "q": q
'}
#Create a PDF from a HTML string using Python
	#Export to a file or Stream
	#To view the file in the browser, use "inline" for the media_type
	#Create a FileResponse object with the file path, media type and headers
	#Return the FileResponse object
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'@app.@get("/pdf") async def get_pdf(greet1: str = None,greet2: str = None): renderer = ChromePdfRenderer() 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) pdf.SaveAs("fastapi.pdf") headers = { "Content-Disposition": "inline; filename=sample.pdf" } response = FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers) 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"

IRON VB CONVERTER ERROR developers@ironsoftware.com

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.