Comment personnaliser la sérialisation et la validation des données avec Pydantic ?

Pydantic est une bibliothèque Python qui permet la validation de données et la sérialisation de modèles en respectant des contraintes spécifiques. Elle repose sur l'utilisation de types Python et de modèles de données, ce qui permet de garantir la validité des données tout en offrant des options de personnalisation avancées. À travers cette approche, Pydantic permet de gérer des cas complexes de sérialisation et de validation, particulièrement dans des environnements comme les API web, où la conformité des données est essentielle.

python
Copy code
u = UserModel(id=1, username="freethrow", email="[email protected]", password="password123")
print(u.model_dump())

python
Copy code
print(u.model_dump_json(exclude=set("password")))

En ce qui concerne la sérialisation, Pydantic permet également d'ajouter des alias et des configurations spécifiques dans le modèle en utilisant ConfigDict. Par exemple, il est possible de définir des règles sur la façon dont un modèle accepte ou rejette les données supplémentaires qui ne sont pas définies dans sa structure. Cela est utile pour des applications où les modèles doivent strictement correspondre aux spécifications et ne pas accepter de données supplémentaires. Le champ model_config avec l'option extra="forbid" garantit qu'aucune donnée additionnelle non déclarée ne sera acceptée, entraînant une erreur de validation si des données imprévues sont fournies.

Dans des cas plus complexes, Pydantic offre la possibilité d’utiliser des sérialiseurs personnalisés avec le décorateur @field_serializer. Ces sérialiseurs vous permettent de contrôler le format de sortie des champs spécifiques lors de la sérialisation en Python ou JSON. Par exemple, pour un modèle de compte bancaire, vous pouvez personnaliser la façon dont le solde est sérialisé pour qu'il soit toujours arrondi à deux décimales :

python
Copy code
from pydantic import BaseModel, field_serializer

from datetime import datetime
class Account(BaseModel):
    balance: float
    updated: datetime
    @field_serializer("balance", when_used="always")
    def serialize_balance(self, value: float) -> float:
        return round(value, 2)
    @field_serializer("updated", when_used="json")

    def serialize_updated(self, value: datetime) -> str:

        return value.isoformat()

Lors de la sérialisation en JSON, la date est formatée en ISO, tandis que le solde est arrondi à deux chiffres après la virgule. Cela permet de garantir un formatage cohérent des données, quel que soit le type de sérialisation utilisé.

Il existe également des décorateurs pour la validation des champs. Le décorateur @field_validator est utilisé pour valider des données spécifiques avant leur traitement. Par exemple, dans un modèle d'article, un validateur peut s'assurer que le titre contient toujours une chaîne particulière, comme "FARM stack" :

python
Copy code
from pydantic import BaseModel, field_validator

class Article(BaseModel):
    id: int
    title: str
    content: str
    published: bool
    @field_validator("title")
    @classmethod
    def check_title(cls, v: str) -> str:
        if "FARM stack" not in v:
            raise ValueError('Title must contain "FARM stack"')
        return v.title()

Au-delà de la validation de champs individuels, Pydantic offre également une fonctionnalité avancée pour effectuer des validations au niveau du modèle entier grâce aux model_validator. Ces validateurs permettent de traiter des interactions complexes entre plusieurs champs d’un même modèle, offrant ainsi une validation plus granulaire et flexible.

Dans un cas classique, un modèle utilisateur pourrait nécessiter la validation que deux mots de passe fournis par l'utilisateur sont identiques. Voici un exemple de la façon dont cela peut être réalisé :

python
Copy code
from pydantic import BaseModel, model_validator

class UserModelV(BaseModel):
    id: int
    username: str
    email: str
    password1: str
    password2: str
    @model_validator
    def check_passwords(cls, values):
        if values['password1'] != values['password2']:
            raise ValueError('Passwords must match')
        return values

Dans cet exemple, le validateur check_passwords vérifie que les deux mots de passe sont identiques avant de permettre l'instanciation du modèle. Ce type de validation est essentiel dans les applications web, où plusieurs champs peuvent interagir et où des validations complexes doivent être effectuées pour garantir la cohérence des données.

Il est crucial de noter que les personnalisations de sérialisation et de validation ne se limitent pas aux seuls aspects techniques, mais doivent également prendre en compte la sécurité et l'intégrité des données traitées. Lors de l’élaboration d’applications complexes, surtout dans le contexte des API, une validation approfondie permet d’éviter les erreurs liées aux données erronées et garantit la sécurité des informations sensibles, comme les mots de passe et les identifiants.

Comment exploiter les APIRouters et Middleware dans FastAPI pour une gestion efficace des applications complexes

Le concept d'APIRouter dans FastAPI est essentiel pour organiser une application en fonction de ses ressources. En utilisant les arguments optionnels comme les "tags" ou un ensemble de dépendances (par exemple, des exigences d’authentification), un développeur peut affiner la gestion des différentes routes de son application. L’argument "prefix", bien que facultatif, est indispensable car il permet de spécifier l'URL sur laquelle l'APIRouter sera monté. Ce mécanisme offre une structure qui ressemble à celle de deux points d’entrée séparés dans l’application, mais ceux-ci sont regroupés sous des tags spécifiques pour une navigation et un test plus intuitifs. Par exemple, lorsque vous démarrez une application avec Uvicorn, une fois les routes montées, les deux APIRouters peuvent être consultés dans la documentation générée automatiquement, chacun sous son tag respectif. Ce découpage permet d’avoir une gestion claire des différentes sections de l’API.

Un autre concept clé dans FastAPI est celui du middleware, une fonction puissante qui permet d'intercepter et de manipuler les requêtes et les réponses tout au long de leur cycle de vie. Ce mécanisme, que l’on retrouve dans des frameworks comme Django ou Express.js, permet d’ajouter des comportements généraux sur toutes les requêtes reçues par l’application. Le middleware agit en tant que filtre, manipulant à la fois la requête avant qu'elle ne soit traitée par une route spécifique, mais également la réponse avant qu'elle ne soit envoyée au client. Grâce à FastAPI, il est possible de lier un middleware à l'ensemble de l’application ou à un APIRouter spécifique, selon les besoins.

Un exemple classique de middleware dans FastAPI consiste à générer un en-tête aléatoire pour chaque réponse envoyée. En utilisant la fonction randint, une valeur aléatoire est ajoutée dans les en-têtes de chaque réponse HTTP, illustrant comment le middleware peut être utilisé pour enrichir ou personnaliser les informations transmises. Ce processus s’applique à chaque requête traitée par l’application, garantissant ainsi une certaine forme de diversité dans les réponses, utile notamment dans des situations de tests ou d'audits.

Le middleware joue également un rôle crucial dans des cas comme la gestion de l’authentification, le CORS (partage des ressources entre origines), ou même la redirection des utilisateurs, des situations fréquemment rencontrées dans le développement d'applications full-stack. Son utilisation est donc d'une grande importance pour la sécurité et l’efficacité d’une application. Par exemple, dans le contexte d’une application de gestion de ressources, un middleware peut intercepter les requêtes pour vérifier si l’utilisateur est authentifié avant d’autoriser l'accès à des routes spécifiques.

Lorsque vous concevez des applications avec FastAPI, l’un des aspects importants à prendre en compte est la nécessité de bien séparer les responsabilités entre les différents modules. Cela garantit non seulement une meilleure lisibilité et maintenabilité du code, mais aussi une gestion plus aisée des performances et de la sécurité. Par exemple, les middlewares doivent être utilisés avec discernement : bien qu’ils apportent une flexibilité indéniable, un excès de logique dans les middlewares peut entraîner des performances moins optimales, ou même des erreurs si l’ordre d’exécution des middlewares n’est pas bien géré.

En résumé, la maîtrise des APIRouters et des middlewares dans FastAPI vous permet de créer des applications plus modulaires, performantes et sécurisées. Ces outils vous offrent la possibilité de décomposer vos API en unités logiques, tout en intégrant des fonctionnalités supplémentaires au niveau des requêtes et réponses, ce qui simplifie grandement le développement de projets complexes. Cependant, il est essentiel de structurer et d’organiser votre application de manière cohérente, en gardant à l’esprit que la puissance de ces outils vient avec la nécessité d'une bonne gestion des dépendances et des hiérarchies internes de l’application.

Comment construire des composants dynamiques avec React et Tailwind CSS

Tout d'abord, nous avons besoin d'un fichier simple pour notre en-tête, qui sera un composant fonctionnel. Utilisons Tailwind CSS pour définir une structure de base, sans se soucier de la réactivité ou de l'ajout de couleurs complexes. Le fichier Header.jsx peut ressembler à ceci :

jsx
Copy code
const Header = () => {

  return (
    <div className="text-center p-4 bg-purple-500 border-2 border-yellow-500">
      <h1>Hello FARM stack!</h1>
    </div>
  );
};
export default Header;

Ici, nous avons un composant simple qui rend un en-tête stylisé avec Tailwind CSS. Il est centré et a une bordure jaune. Ce composant peut être utilisé dans notre fichier App.jsx, où il sera importé et affiché.

jsx
Copy code
import Header from "./components/Header";

export default function App() {
  const data = [
    { id: 1, name: "Fiat" },
    { id: 2, name: "Peugeot" },
    { id: 3, name: "Ford" },
    { id: 4, name: "Renault" },
    { id: 5, name: "Citroen" },
  ];
  return (
    <div>
      <Header />
      {data.map((el) => {
        return (
          <div key={el.id}>
            Cars listed as {el.name.toUpperCase()}
          </div>
        );
      })}
    </div>
  );
}

Dans cet exemple, un tableau de données de voitures est mappé et affiché après l'en-tête. Ce code est un excellent point de départ pour organiser notre application en composants indépendants et réutilisables.

jsx
Copy code
const Card = ({ car: { name, year, model, price } }) => {
  return (
    <div className="border p-4 m-4">
      <h2>{name}</h2>
      <p>{year} - {model}</p>
      <p>${price}</p>
    </div>
  );
};
export default Card;

Ce composant prend des propriétés (props) pour afficher le nom, l'année, le modèle et le prix d'une voiture. Ensuite, dans notre fichier App.jsx, nous mettons à jour la logique pour utiliser ce composant dynamique :

jsx
Copy code
import { useState } from "react";

import Card from "./components/Card";

export default function App() {

  const data = [
    { id: 1, name: "Fiat", year: 2023, model: "Panda", price: 12000 },
    { id: 2, name: "Peugeot", year: 2018, model: "308", price: 16000 },

    { id: 3, name: "Ford", year: 2022, model: "Mustang", price: 25000 },

    { id: 4, name: "Renault", year: 2019, model: "Clio", price: 18000 },

    { id: 5, name: "Citroen", year: 2021, model: "C3 Aircross", price: 22000 },

    { id: 6, name: "Toyota", year: 2020, model: "Yaris", price: 15000 },

    { id: 7, name: "Volkswagen", year: 2021, model: "Golf", price: 28000 },

    { id: 8, name: "BMW", year: 2022, model: "M3", price: 45000 },
    { id: 9, name: "Mercedes", year: 2021, model: "A-Class", price: 35000 },
    { id: 10, name: "Audi", year: 2022, model: "A6", price: 40000 },
  ];
  const [budget, setBudget] = useState(20000);
  return (
    <div>
      <h1>Your budget is ${budget}</h1>
      <input
        type="number"
        value={budget}
        onChange={(e) => setBudget(e.target.value)}
        className="border p-2"
      />
      {data.map((el) => {

        return <Card key={el.id} car={el} />;

      })}
    </div>
  );
}

Ici, nous avons remplacé l'affichage simple des noms de voitures par des cartes dynamiques qui présentent plus d'informations sur chaque voiture. De plus, le budget de l'utilisateur est pris en compte et peut être modifié via un champ de saisie. Ces cartes sont générées dynamiquement pour chaque voiture en utilisant les données de notre tableau.

Il convient de noter qu'une fois que l'on commence à manipuler plusieurs composants, la gestion de l'état devient cruciale. React fournit une méthode simple pour manipuler l'état via la fonction useState. Cela permet à l'application de répondre aux changements, comme la mise à jour du budget par l'utilisateur dans cet exemple. Cela signifie qu'avec une bonne gestion de l'état et des événements, vous pouvez créer des applications interactives et dynamiques.

Au fur et à mesure de la complexification des applications React, il devient également important de maîtriser la gestion des événements. En React, chaque événement DOM est encapsulé dans un événement synthétique, ce qui rend la gestion des événements plus fiable et cohérente entre les différents navigateurs.

Cela marque un tournant important dans le développement avec React, où la compréhension de la structuration des composants, de la gestion des états et des événements devient essentielle pour construire des applications complexes et modulaires.

Comment structurer les opérations CRUD avec FastAPI pour gérer les ressources d'une application

Dans ce contexte, chaque opération est liée à un objet de données, ici une voiture, qui correspond à un document dans une base de données MongoDB. Nous allons maintenant détailler la façon d'implémenter un routeur API avec FastAPI pour gérer ces opérations.

L'implémentation des opérations commence par la mise en place d'un routeur API, un module conçu pour gérer un groupe d'opérations liées à un type spécifique de ressource, ici les voitures. Cela implique la création d'un dossier spécifique au sein de votre projet, le routeur étant ensuite intégré dans l'application principale FastAPI. La création d'un routeur spécifique aux voitures est une bonne pratique, car elle permet d'organiser le code de manière modulaire et extensible.

Mise en place du routeur API pour les voitures

La première étape consiste à créer un dossier dédié à vos routeurs, typiquement appelé /routers, dans lequel vous allez inclure un fichier cars.py. Ce fichier sera le premier routeur de votre application. Il est conseillé de nommer les routeurs en fonction des ressources qu'ils gèrent, ici "cars" pour les voitures.

python
Copy code
from fastapi import APIRouter, Body, Request, status
from models import CarModel
router = APIRouter()

Création de l'endpoint POST : Ajouter une voiture

Le premier gestionnaire que nous allons créer est un gestionnaire pour la méthode POST, qui permet d'ajouter une nouvelle voiture à la base de données. Voici un exemple d'implémentation de cet endpoint :

python
Copy code
@router.post(
    "/",
    response_description="Ajoute une nouvelle voiture",
    response_model=CarModel,
    status_code=status.HTTP_201_CREATED,
    response_model_by_alias=False,
)

async def add_car(request: Request, car: CarModel = Body(...)):

    cars = request.app.db["cars"]
    document = car.model_dump(
        by_alias=True, exclude=["id"]
    )
    inserted = await cars.insert_one(document)
    return await cars.find_one({"_id": inserted.inserted_id})

Dans ce code, nous définissons un handler pour la méthode POST. Le modèle CarModel est utilisé pour valider les données reçues dans le corps de la requête. Ensuite, un document est créé à partir de ces données, et il est inséré dans la collection cars de la base de données MongoDB. En retour, nous renvoyons l'objet voiture avec son identifiant généré par la base de données.

Création de l'endpoint GET : Lire les voitures

Ensuite, nous devons créer un gestionnaire pour la méthode GET, qui permet de récupérer les voitures stockées dans la base de données. Il peut s'agir d'un seul élément ou de plusieurs éléments en fonction des besoins.

Voici un exemple d'implémentation pour l'endpoint GET qui retourne toutes les voitures :

python
Copy code
@router.get(

    "/",
    response_description="Liste toutes les voitures",
    response_model=CarCollection,
    response_model_by_alias=False,
)
async def list_cars(request: Request):
    cars = request.app.db["cars"]
    results = []
    cursor = cars.find()
    async for document in cursor:
        results.append(document)
    return CarCollection(cars=results)

Une alternative à la méthode async for consiste à utiliser la méthode to_list() pour récupérer les résultats sous forme de liste directement :

python
Copy code
return CarCollection(
    cars=await cars.find().to_list(1000)
)

Validation des données et gestion des erreurs

Lors de la mise en place de ces endpoints, il est important de valider correctement les données envoyées par les utilisateurs. FastAPI facilite cette validation grâce à son intégration avec Pydantic, ce qui permet de définir des modèles de données robustes et flexibles. Lorsque des données invalides sont envoyées, FastAPI renvoie automatiquement des réponses d'erreur bien structurées, ce qui permet à l'utilisateur de comprendre rapidement la nature du problème.

Extensibilité et meilleures pratiques

À mesure que votre application se développe, il peut être nécessaire d'ajouter des fonctionnalités supplémentaires. Par exemple, l'ajout de la gestion des utilisateurs pour associer chaque voiture à un utilisateur spécifique, ou la mise en place de mécanismes d'authentification et d'autorisation pour sécuriser l'accès aux données. FastAPI permet une telle extensibilité grâce à sa capacité à gérer plusieurs routeurs et à intégrer des middleware.

Il est également important de respecter certaines bonnes pratiques, comme la gestion des erreurs et des exceptions, l'utilisation de schémas de réponse cohérents, et l'organisation du code en modules bien structurés. Un code propre et bien organisé facilite non seulement la maintenance, mais aussi l'évolutivité de l'application.