Créer des composants robustes avec FastAPI et Pydantic

Tirer parti d'objets bien définis pour une validation efficace des données

Les objets servent de points d'entrée et de sortie pour les composants, agissant comme des passerelles fondamentales pour le flux de données. Pour créer des composants robustes et maintenables, il est essentiel de définir des champs clairs et bien structurés au sein de ces objets. Cela garantit l’intégrité des données et des interactions fiables entre les différentes parties du système. Personnellement, je préfère utiliser Python avec le framework FastAPI pour développer des API modernes et performantes. Pour la validation des données, Pydantic est ma bibliothèque de choix, s'intégrant parfaitement à FastAPI pour appliquer avec élégance les contraintes de champ et maintenir la cohérence dans tout le système.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, EmailStr, Field, ValidationError, conint

# FastAPI instance
app = FastAPI()

# Pydantic model for request body validation
class User(BaseModel):
    name: str = Field(..., min_length=3, max_length=50, description="Name must be between 3 and 50 characters")
    age: conint(gt=0, le=120) = Field(..., description="Age must be between 1 and 120")  # Constrained integer type
    email: EmailStr = Field(..., description="Must be a valid email address")

# API route to handle user data submission
@app.post("/create-user/")
async def create_user(user: User):
    try:
        # If validation passes, this will run
        return {"message": f"User {user.name} created successfully!"}
    except ValidationError as e:
        # Catch and return validation errors
        raise HTTPException(status_code=400, detail=e.errors())

# Sample invalid data
invalid_data = {"name": "A", "age": -5, "email": "invalid_email"}

# Simulate calling the route with invalid data
@app.get("/test-invalid-data/")
async def test_invalid_data():
    try:
        user = User(**invalid_data)  # Validation will fail here
    except ValidationError as e:
        return {"error": e.errors()}

# Run the server using: uvicorn <filename>:app --reload

Dans cet exemple, nous démontrons comment FastAPI et Pydantic travaillent ensemble pour gérer efficacement la validation des données. À l'aide du BaseModel de Pydantic, nous définissons des règles de validation pour les données des requêtes entrantes. Par exemple, nous utilisons EmailStr pour valider automatiquement les formats d'e-mail, simplifiant ainsi le processus sans avoir besoin d'expressions régulières personnalisées. De même, nous utilisons conint (un type entier contraint) pour garantir que l'âge se situe dans une plage spécifique, de 1 à 120. Cette approche améliore la lisibilité et la sécurité.

Dans l'exemple de code, un modèle Utilisateur est défini avec des champs tels que le nom, l'âge et l'e-mail, chacun ayant ses critères de validation. Lorsqu'un utilisateur soumet des données via la route /create-user/, FastAPI valide automatiquement l'entrée par rapport à ces règles. S'il est valide, l'utilisateur est créé avec succès ; sinon, FastAPI génère une 400 Bad Request avec des messages d'erreur détaillés. Cela réduit considérablement le risque de traitement de données incorrectes ou malveillantes, faisant de FastAPI un choix puissant pour le développement sécurisé d'API.

Validation de champ/modèle personnalisé avec Pydantic

Pydantic v2 introduit la validation au niveau du modèle, vous permettant de valider plusieurs champs les uns par rapport aux autres à l'aide du décorateur @model_validator. Cette validation s'exécute après la validation des champs et est particulièrement utile pour garantir que certaines conditions entre les champs sont remplies. Par exemple, vous souhaiterez peut-être confirmer qu'une start_date se produit avant une end_date dans un modèle d'événement :

from pydantic import BaseModel, model_validator
from datetime import date

class Event(BaseModel):
    name: str
    start_date: date
    end_date: date

    @model_validator(mode='after')
    def check_dates(cls, values):
        start, end = values.get('start_date'), values.get('end_date')
        if start and end and start >= end:
            raise ValueError('start_date must be before end_date')
        return values

Dans cet exemple, le @model_validator vérifie que start_date est antérieur à end_date. Si cette condition n'est pas remplie, Pydantic génère une erreur de validation. Cette validation au niveau du modèle est bénéfique pour garantir que les relations entre plusieurs champs sont appliquées avec précision.

Sérialisation personnalisée dans Pydantic

Pydantic permet une sérialisation personnalisée des champs du modèle en remplaçant les méthodes dict() ou json(). Ceci est utile lorsque vous souhaitez modifier le format de sortie ou exclure certains champs lors de la sérialisation. Vous pouvez également utiliser le décorateur @property pour ajouter des champs calculés qui sont inclus dans la sérialisation mais ne font pas partie des données brutes du modèle.

Voici un exemple de sérialisation personnalisée qui modifie la façon dont un nom complet est renvoyé tout en excluant le champ du mot de passe de la sortie sérialisée :

from pydantic import BaseModel

class User(BaseModel):
    first_name: str
    last_name: str
    password: str

    # Custom serialization to return the full name
    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    # Overriding dict() to exclude the password
    def dict(self, **kwargs):
        result = super().dict(**kwargs)
        result['full_name'] = self.full_name  # Add computed field
        result.pop('password', None)  # Remove password from serialization
        return result

# Example usage
user = User(first_name="John", last_name="Doe", password="secret123")
print(user.dict())

Dans cet exemple, full_name est une propriété calculée et nous remplaçons la méthode dict() pour garantir que le mot de passe est exclu de la sortie. Une sérialisation personnalisée comme celle-ci offre un contrôle précis sur la manière dont les données du modèle sont exposées dans les API ou les réponses.

Intégration FastAPI et Pydantic

Pydantic s'intègre parfaitement à FastAPI, fournissant une validation automatique des données pour les charges utiles des requêtes, les paramètres de requête et les paramètres de chemin. Lorsque vous définissez un modèle Pydantic dans un point de terminaison FastAPI, FastAPI gère automatiquement l'analyse et la validation des données entrantes par rapport aux règles du modèle. Si les données ne sont pas valides, FastAPI renvoie une réponse détaillée 422 Unprocessable Entity avec des messages d'erreur clairs.

Voici un exemple simple :

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    username: str
    age: int

@app.post("/users/")
async def create_user(user: User):
    return {"message": f"User {user.username} created successfully!"}

Dans cet exemple, lorsqu'une requête POST est envoyée à /users/, FastAPI utilise Pydantic pour valider les données JSON entrantes. Si les données ne sont pas conformes au modèle utilisateur (par exemple, nom d'utilisateur manquant ou âge invalide), FastAPI renvoie automatiquement une réponse d'erreur, simplifiant la validation des entrées et la gestion des erreurs.

Résumé

En résumé, tirer parti de Pydantic avec FastAPI améliore votre capacité à créer des applications robustes et maintenables en garantissant l'intégrité des données grâce à des validations claires. Cette puissante combinaison simplifie le processus de développement tout en améliorant la sécurité et la fiabilité, ce qui en fait un choix privilégié pour créer des API modernes.

Références

Fonctionnalités pydantiques dans FastAPI
Plan Pydantique V2

---

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!