FastAPI est un framework Python moderne et rapide pour créer des APIs basées sur les standards.

Sa simplicité, son interactivité et ses performances en font un choix idéal pour les développeurs cherchant à concevoir des APIs robustes et performantes.

⚙️ Pré-requis

Avant de te lancer dans cette quête, il est préférable de savoir déjà :

• Avoir une connaissance de base des APIs REST (concepts comme HTTP, JSON, endpoints)
• Comprendre les bases de Python (fonctions, modules, types de données)
• Disposer de Python 3.7 ou plus sur ta machine
• Savoir utiliser un terminal pour exécuter des commandes basiques

🎯 Objectifs :

✅ Comprendre les bases des API REST
✅ Apprendre à utiliser FastAPI pour créer une API REST
✅ Manipuler les routes, les paramètres et les données en FastAPI
✅ Tester, valider et documenter votre API efficacement

🌐 Qu'est-ce qu'une API REST ?

Une API REST (Representational State Transfer) est un style architectural utilisé pour créer des interfaces permettant la communication entre différentes applications, souvent sur le Web, via le protocole HTTP. Elle est largement adoptée grâce à sa simplicité, sa flexibilité, et son utilisation efficace des standards web existants.

Pourquoi REST ?

REST est basé sur les principes fondamentaux du Web, ce qui le rend facile à comprendre et à intégrer.

Il se concentre sur l'utilisation des standards HTTP pour structurer les interactions entre les clients (comme un navigateur ou une application mobile) et les serveurs.

Principes fondamentaux d'une API REST

1. Stateless (Sans état) :

   • Chaque requête envoyée par le client contient toutes les informations nécessaires pour que le serveur la comprenne et la traite. Cela signifie qu'aucune donnée de session n'est sauvegardée côté serveur entre deux requêtes.
   • Avantages :
     • Évolutivité : Les serveurs peuvent gérer plus de requêtes, car ils n'ont pas à stocker d'informations de session.
     • Simplicité : Chaque requête est indépendante, ce qui rend le débogage et les tests plus simples.

2. Basée sur HTTP : REST s'appuie sur les méthodes HTTP bien connues :

   • GET : Récupérer des données (lecture seule). Par exemple, récupérer une liste de produits.
   • POST : Envoyer des données ou créer de nouvelles ressources. Par exemple, ajouter un nouvel utilisateur.
   • PUT : Mettre à jour ou remplacer une ressource existante.
   • DELETE : Supprimer une ressource existante.
   • Autres méthodes : Dans certains cas, on peut aussi utiliser PATCH (mise à jour partielle) ou HEAD (obtenir uniquement les en-têtes HTTP).

3. Ressources identifiées par des URLs : Chaque ressource manipulée par l'API est accessible via une URL unique. Une ressource peut représenter :

   • Un objet spécifique (/users/123 pour l'utilisateur avec l'ID 123).
   • Une collection d'objets (/users pour la liste des utilisateurs).
   • Une relation entre des objets (/users/123/orders pour les commandes de l'utilisateur 123).

   Les noms d'URLs doivent être explicites et refléter les données qu'elles représentent. Exemple :

   • /products pour une liste de produits.
   • /products/456 pour un produit spécifique identifié par son ID.

4. Format d'échange de données :

   • Les données sont généralement échangées sous forme de JSON (JavaScript Object Notation), un format léger, lisible par les humains et largement supporté.
   • D'autres formats comme XML, HTML, ou YAML peuvent aussi être utilisés, mais le JSON reste le plus courant.
   • Exemple de réponse JSON pour une ressource utilisateur :
     json

     {
       "id": 123,
       "name": "John Doe",
       "email": "johndoe@example.com"
     }
     

🎯 Exemple concret d'une API REST

Imaginons une API REST pour gérer des utilisateurs :

Exemple détaillé d'une réponse pour /users (GET) :

[
   {
      "id": 1,
      "name": "Alice",
      "email": "alice@example.com"
   },
   {
      "id": 2,
      "name": "Bob",
      "email": "bob@example.com"
   }
]

Concepts avancés à connaître

1. HATEOAS (Hypermedia As The Engine Of Application State) :

   • Les APIs REST peuvent inclure des liens hypertextes dans leurs réponses pour guider les clients vers des actions possibles. Par exemple :
     json

     {
       "id": 123,
       "name": "John Doe",
       "links": [
          {"rel": "self", "href": "/users/123"},
          {"rel": "delete", "href": "/users/123/delete"}
       ]
     }
     

2. Versionnement :

   • Pour garantir la compatibilité entre différentes versions d'une API, il est courant d'inclure un numéro de version dans l'URL :
     • Exemple : /v1/users ou /v2/users.

3. Codes de statut HTTP :

   • Les APIs REST utilisent des codes HTTP standard pour indiquer le résultat d'une requête :
     • 200 OK : Requête réussie.
     • 201 Created : Une nouvelle ressource a été créée.
     • 400 Bad Request : Erreur dans la requête envoyée.
     • 404 Not Found : Ressource introuvable.
     • 500 Internal Server Error : Erreur côté serveur.

4. Sécurité :

   • REST ne définit pas directement de mécanismes de sécurité, mais il est courant d'utiliser des solutions comme :
     • OAuth 2.0 pour l'authentification.
     • HTTPS pour chiffrer les données échangées.

Pourquoi REST est-il si populaire ?

1. Simplicité : Les concepts REST sont faciles à comprendre et à implémenter.
2. Interopérabilité : Étant basé sur les standards web, REST peut être utilisé avec presque toutes les technologies.
3. Flexibilité : REST permet d'exposer des APIs adaptées à une grande variété de clients (web, mobile, IoT).
4. Évolutivité : Sa nature stateless facilite la répartition de la charge entre plusieurs serveurs.

FastAPI est un framework Python moderne, conçu pour créer des APIs REST performantes et fiables.

Avec sa documentation automatique, sa validation intégrée et son support asynchrone, il est adapté aussi bien aux débutants qu'aux experts.

Ce framework repose sur deux piliers principaux :

• Starlette : pour gérer les requêtes HTTP et les fonctionnalités asynchrones.
• Pydantic : pour la validation des données et la gestion des modèles.

L'objet principal : FastAPI

L'objet FastAPI agit comme le coeur de l'application, gérant les routes, la validation des données et la documentation.

Exemple :

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Bienvenue sur FastAPI !"}

Gestion des requêtes et réponses avec Starlette

Starlette facilite la gestion des requêtes HTTP et des réponses JSON via des classes dédiées.

Exemple :

from starlette.applications import Starlette
from starlette.requests import Request
from starlette.responses import JSONResponse

app = Starlette()

@app.route("/greet", methods=["POST"])
async def greet_user(request: Request):
    data = await request.json()
    name = data.get("name", "Invité")
    return JSONResponse({"message": f"Bonjour, {name} !"})

• Request : Permet d'accéder aux données de la requête, comme le corps, les en-têtes, ou les paramètres.
• JSONResponse : Génère une réponse au format JSON.

Validation des données avec Pydantic

Pydantic est utilisé pour valider les entrées et sorties des endpoints.

Exemple :

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    description: str = None

Documentation interactive

FastAPI génère une documentation interactive accessible à /docs (Swagger UI) et /redoc.

Starlette est un microframework Python léger et rapide pour construire des applications web et des APIs.

Il est conçu pour des performances élevées, grâce à sa compatibilité native avec le modèle asynchrone d’ASGI (Asynchronous Server Gateway Interface).

Starlette est la base sur laquelle FastAPI est construit, fournissant le moteur HTTP et des outils puissants pour gérer les requêtes et les réponses.

Pourquoi utiliser Starlette ?

1. Performances élevées : Starlette est conçu pour des applications web rapides et légères, rivalisant avec les frameworks modernes comme Node.js.

2. Support natif d'ASGI : Compatible avec les serveurs ASGI comme Uvicorn et Daphne, ce qui permet la gestion des websockets, des tâches en arrière-plan et des requêtes HTTP classiques.

3. Simplicité et modularité : Fournit des outils puissants comme le routage, les middlewares, et la gestion des sessions, tout en restant léger. Base de FastAPI :

Comprendre Starlette aide à mieux comprendre les rouages internes de FastAPI.

Comment fonctionne Starlette ?

Une application Starlette est une instance de la classe Starlette, semblable à l’objet FastAPI.

Exemple :

from starlette.applications import Starlette
from starlette.responses import JSONResponse

app = Starlette()

@app.route("/")
async def homepage(request):
    return JSONResponse({"message": "Bienvenue sur Starlette !"})

• @app.route : Définit une route pour gérer une URL spécifique
• JSONResponse : Permet de renvoyer une réponse JSON

Middleware dans Starlette

Un middleware est un composant qui intercepte chaque requête ou réponse pour y ajouter une fonctionnalité. Par exemple, la gestion des CORS (Cross-Origin Resource Sharing) est un middleware typique.

Exemple :

from starlette.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Autorise toutes les origines
    allow_methods=["*"],  # Autorise toutes les méthodes HTTP
    allow_headers=["*"],  # Autorise tous les headers
)

Ici, les requêtes provenant de n'importe quelle origine sont autorisées.

Gestion des routes dynamiques

Starlette permet de définir des routes dynamiques, avec des paramètres capturés directement depuis l’URL.

Exemple :

from starlette.routing import Route
from starlette.responses import JSONResponse

async def get_user(request):
    user_id = request.path_params["user_id"]
    return JSONResponse({"user_id": user_id})

routes = [
    Route("/users/{user_id}", get_user),
]

app = Starlette(routes=routes)

• path_params : Permet d’extraire des paramètres d’URL dynamiques

Gestion des erreurs

Starlette permet de capturer et gérer les erreurs globalement grâce à des exception handlers.

Exemple :

from starlette.exceptions import HTTPException
from starlette.responses import JSONResponse

async def not_found_handler(request, exc):
    return JSONResponse({"error": "Ressource introuvable"}, status_code=404)

app.add_exception_handler(HTTPException, not_found_handler)

• add_exception_handler : Associe un type d'exception à une fonction qui gère cette exception

Support des Websockets

Starlette permet de gérer des connexions websockets, ce qui est idéal pour des applications en temps réel.

Exemple :

from starlette.websockets import WebSocket

@app.websocket_route("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    await websocket.send_text("Bienvenue sur le WebSocket")
    await websocket.close()

Background tasks

Avec Starlette, il est facile d’exécuter des tâches en arrière-plan grâce aux background tasks.

Exemple :

from starlette.background import BackgroundTask
from starlette.responses import JSONResponse

async def send_email(email: str):
    # Simule l'envoi d'un email
    print(f"Email envoyé à {email}")

@app.route("/send-email")
async def send_email_route(request):
    task = BackgroundTask(send_email, email="example@example.com")
    return JSONResponse({"message": "Email en cours d'envoi"}, background=task)

Fonctionnalités avancées

• Routing flexible : Starlette permet de définir des routes avec des classes ou des fonctions asynchrones
• TestClient : Fournit un outil simple pour tester les routes en interne
• GraphQL : Intègre des outils pour gérer des APIs GraphQL
• Streaming et fichiers : Permet de gérer les uploads et téléchargements de fichiers

Pydantic est une bibliothèque Python utilisée pour valider les données et gérer les schémas.

Dans FastAPI, elle est utilisée pour structurer, valider et documenter les données des APIs.

Pourquoi utiliser Pydantic ?

1. Validation automatique :

   • Chaque donnée envoyée par un client (JSON, query params, etc.) est validée automatiquement
   • Les erreurs sont gérées proprement avec des messages détaillés

2. Typage fort :

   • Pydantic utilise les annotations de type Python pour définir les modèles
   • Par exemple, un champ défini comme int ne peut pas accepter une chaîne de caractères

3. Sérialisation et conversion :

   • Pydantic convertit automatiquement les données en types Python natifs (exemple : JSON → datetime)

4. Documenter les APIs :

   • Les modèles Pydantic sont utilisés pour générer automatiquement les schémas JSON (OpenAPI), ce qui alimente la documentation Swagger UI

Comment fonctionne Pydantic ?

Un modèle Pydantic est une classe qui hérite de BaseModel.

Chaque champ de la classe représente une donnée avec son type et éventuellement une valeur par défaut.

Exemple :

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    description: str = None
    tax: float = 0.0

Fonctionnalités avancées de Pydantic

Tu peux définir des validations avancées avec des méthodes décorées par @validator.

Exemple :

from pydantic import BaseModel, validator

class User(BaseModel):
    username: str
    password: str

    @validator("password")
    def validate_password(cls, value):
        if len(value) < 8:
            raise ValueError("Le mot de passe doit contenir au moins 8 caractères.")
        return value

Swagger UI est un outil essentiel pour explorer et tester les APIs. Avec FastAPI, il s'intègre naturellement grâce au standard OpenAPI, qui décrit les endpoints, les modèles de données et les méthodes HTTP disponibles.

Génération automatique

L'un des atouts majeurs de FastAPI est que Swagger UI est généré automatiquement, sans effort supplémentaire.

Dès que tu crées une application FastAPI, la documentation interactive Swagger UI est accessible par défaut à l'URL /docs.

Une alternative, appelée ReDoc, est disponible à /redoc.

Interface de visualisation via la route /docs

Ces interfaces permettent de visualiser et tester facilement les endpoints directement depuis ton navigateur.

Prenons un exemple simple. Si tu définis une API avec un modèle Pydantic et une route POST, comme ceci :

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    description: str = None

@app.post("/items/")
def create_item(item: Item):
    return {"message": f"Item '{item.name}' ajouté avec succès", "price": item.price}

FastAPI génère automatiquement une interface Swagger UI pour cet endpoint.

Lorsque tu accèdes à /docs, tu verras un formulaire interactif pour tester la route /items/.

Ce formulaire affiche les champs nécessaires comme name et price, tout en signalant que description est facultatif.

Tu peux saisir directement les données et envoyer une requête POST pour observer la réponse JSON.

Swagger UI ne se limite pas à afficher les routes.

Il génère également des informations détaillées sur les erreurs, les types de données attendus et les exemples de requêtes.

Par exemple, si un client envoie un champ manquant ou un type incorrect, la documentation Swagger UI montre comment corriger ces erreurs en se basant sur les modèles définis.

Voici une capture du rendu pour te faire une idée :

Personnalisation

En termes de personnalisation, FastAPI offre plusieurs possibilités.

Tu peux changer le titre et la description de l’API pour qu’ils correspondent à ton projet :

app = FastAPI(
    title="API de gestion d'items",
    description="Une API simple pour gérer des items avec FastAPI.",
    version="1.0.0",
)

Quand un projet FastAPI grandit, il est important d'organiser les fichiers et dossiers pour garantir une bonne lisibilité et maintenabilité.

Voici une structure de projet standard :

.
├── app/
│   ├── __init__.py
│   ├── main.py            # Point d'entrée de l'application
│   ├── models.py          # Modèles de base de données
│   ├── routes/            # Dossiers contenant les routes (endpoints)
│   │   ├── __init__.py
│   │   ├── items.py       # Exemple : routes pour les "items"
│   ├── schemas.py         # Définition des schémas avec Pydantic
│   ├── database.py        # Configuration de la base de données
│   ├── config.py          # Configuration de l'application
├── tests/                 # Tests unitaires et fonctionnels
│   ├── __init__.py
│   ├── test_items.py
├── requirements.txt       # Dépendances Python
└── README.md              # Documentation du projet

Ce cas pratique te guide à travers la création d’un projet FastAPI organisé, avec une structure claire et des routes simples.

À la fin de ces étapes, tu auras une API fonctionnelle avec des endpoints documentés que tu pourras tester et étendre.

1. 1

   Étape 1 : Installation des dépendances

   Avant de commencer, assure-toi que Python 3.7 ou une version plus récente est installé sur ton système.

   Il est également recommandé de passer par un venv.

   bash

   python3 -m venv .venv
   source .venv/bin/activate(.fish|.zsh|.bat)
   

   Ensuite, installe FastAPI et Uvicorn, le serveur ASGI recommandé pour exécuter les applications FastAPI.

   bash

   pip install fastapi uvicorn
   

   Que fait cette commande ?

   Installe le framework FastAPI, qui fournit les outils pour créer des APIs performantes.

   Installe Uvicorn, un serveur rapide et léger pour exécuter les applications ASGI.

   Une fois l’installation terminée, vérifie que les modules sont bien disponibles en exécutant :

   python

   python -c "import fastapi, uvicorn; print('Installation réussie !')"
   

2. 2

   Étape 2 : Création du projet

   Crée un répertoire pour ton projet et organise-le comme suit :

   tree

   app/
   ├── __init__.py
   ├── main.py            # Point d'entrée de l'application
   ├── routes/            # Contient les fichiers de routes
   │   ├── __init__.py
   │   ├── items.py       # Routes pour la gestion des "items"
   ├── schemas.py         # Modèles de données avec Pydantic
   ├── models.py          # Modèles de base de données (à utiliser plus tard)
   ├── database.py        # Configuration de la base de données (à venir)
   

   Pourquoi cette structure ?

   • main.py : Contient l'application FastAPI et configure les routes.
   • routes/ : Sépare les différentes fonctionnalités en modules pour une meilleure organisation.
   • schemas.py : Définit les schémas de données pour valider les entrées et sorties des endpoints.
   • models.py et database.py : Pour l'intégration future d'une base de données.

   Tu peux ignorer les fichiers models.py et database.py pour le moment. Ils seront utiles si tu ajoutes une base de données à ton projet plus tard.

3. 3

   Étape 3 : Configuration de la route principale

   Dans le fichier main.py, configure ton application et définis une route de base pour tester que tout fonctionne correctement.

   python

   from fastapi import FastAPI
   from app.routes import items
   
   app = FastAPI()
   
   @app.get("/")
   def read_root():
       return {"message": "Bienvenue sur FastAPI !"}
   

   Que fait ce code ?

   • FastAPI() : Initialise l’application.
   • include_router : Connecte les routes définies dans routes/items.py avec le préfixe /items. Cela signifie que tous les endpoints dans items.py seront accessibles via /items/....
   • Route / : Définit une route simple à la racine de l’application, qui renvoie un message de bienvenue.

   Comment tester ?

   Exécute l’application avec Uvicorn :

   python

   uvicorn app.main:app --reload
   

   Ouvre ton navigateur et visite http://127.0.0.1:8000. Tu devrais voir un message comme :

   json

   {
       "message": "Bienvenue sur FastAPI !"
   }
   

4. 4

   Étape 4 : Définition des routes

   Ajoute un fichier routes/items.py et définis-y des routes pour gérer une collection d’items.

   Ce fichier contiendra deux routes :

   • Une pour obtenir la liste des items.
   • Une autre pour obtenir les détails d’un item spécifique.

   python

   from fastapi import APIRouter
   
   router = APIRouter()
   
   @router.get("/")
   def get_items():
       return [{"item_id": 1, "name": "Item One"}, {"item_id": 2, "name": "Item Two"}]
   
   @router.get("/{item_id}")
   def get_item(item_id: int):
       return {"item_id": item_id, "name": f"Item {item_id}"}
   

   Que fait ce code ?

   • Définit deux endpoints :
     • GET /items/ : Retourne une liste d’items.
     • GET /items/{item_id} : Retourne les détails d'un item spécifique basé sur son ID.
   • Utilise un routeur (APIRouter) pour regrouper les endpoints liés aux items.

   Et il te faut ajouter ceci dans le fichier main.py en dessous de app = FastAPI() :

   python

   app.include_router(items.router, prefix="/items", tags=["items"]) # 
   

   Comment tester ?

   Lance l'application avec Uvicorn.

   Visite http://127.0.0.1:8000/items/ pour obtenir la liste des items.

   Accède à http://127.0.0.1:8000/items/1 pour obtenir les détails de l’item avec l'ID 1.

true||true|||true
# Quelle méthode est utilisée pour définir un modèle de données avec validation dans FastAPI ?
[] define_model
[x] Pydantic BaseModel
[] StarletteModel
[] ValidateModel

# À quoi sert la méthode `include_router` dans FastAPI ?
[] Ajouter une route dynamique
[x] Connecter un ensemble de routes à l'application principale
[] Initialiser un modèle de données
[] Configurer un middleware

# Quelle URL par défaut fournit la documentation OpenAPI pour une application FastAPI ?
[x] /docs
[] /openapi
[] /api-docs
[] /documentation

# Quelle bibliothèque est utilisée pour fournir le serveur ASGI recommandé dans FastAPI ?
[] Flask
[] Django
[x] Uvicorn
[] StarletteServer

# Quel objet est utilisé pour capturer les données d'une requête dans Starlette ?
[] RequestData
[] Query
[x] Request
[] HTTPBody

# Comment retourner une réponse JSON dans une application Starlette ?
[] return JsonResponse(data)
[] response.json(data)
[x] JSONResponse({"key": "value"})
[] return data.to_json()

# Quel fichier dans la structure typique d'un projet FastAPI contient les routes principales ?
[] routes.py
[x] main.py
[] schemas.py
[] models.py

# Quelle commande exécute une application FastAPI avec rechargement automatique ?
[] fastapi run
[] start-fastapi
[x] uvicorn main:app --reload
[] python runserver

# Quel est l'objectif principal de OpenAPI dans FastAPI ?
[] Configurer les middlewares
[] Gérer les erreurs
[x] Documenter et tester les APIs
[] Générer des modèles de données

# Quel type de serveur est nécessaire pour exécuter une application compatible ASGI comme FastAPI ?
[x] ASGI
[] WSGI
[] CGI
[] HTTPServer

💪 Challenge : Créer une API FastAPI pour gérer des tâches

Crée une API complète avec FastAPI qui gère une liste de tâches, tout en mettant en pratique les concepts abordés. Cette API permettra d'ajouter, de visualiser, de modifier, et de supprimer des tâches.

L'objectif est d'appliquer les connaissances sur FastAPI, Pydantic, et les concepts d'organisation des projets, tout en construisant une API REST fonctionnelle.

🧩 Objectifs

1. Construire une API fonctionnelle avec FastAPI.
2. Utiliser Pydantic pour définir les modèles de données.
3. Créer des endpoints pour gérer les tâches (CRUD : Create, Read, Update, Delete).
4. Tester l'API à l'aide de Swagger UI ou d'un client comme Postman.
5. Organiser le projet avec une structure claire.
6. Publier le projet sur un dépôt GitLab.

⚙️ Fonctionnalités attendues

Ton API devra inclure les fonctionnalités suivantes :

1. Afficher la liste des tâches :

   • Retourner toutes les tâches dans un format JSON.
   • Chaque tâche doit inclure un id, un title, un description, et un completed.

2. Ajouter une nouvelle tâche :

   • Recevoir les détails d'une tâche via un endpoint POST et les sauvegarder.

3. Modifier une tâche existante :

   • Mettre à jour une tâche spécifique en fonction de son id.

4. Supprimer une tâche :

   • Supprimer une tâche spécifique de la liste en fonction de son id.

5. Marquer une tâche comme terminée :

   • Ajouter un endpoint pour changer le statut completed d'une tâche.

📋 Spécifications techniques

• Modèle de données :

  • Utilise un modèle Pydantic avec les champs suivants :
    • id : entier (généré automatiquement).
    • title : chaîne de caractères (obligatoire).
    • description : chaîne de caractères (facultatif).
    • completed : booléen (par défaut False).

• Endpoints à implémenter :

  • GET /tasks/ : Retourne la liste de toutes les tâches.
  • POST /tasks/ : Ajoute une nouvelle tâche.
  • PUT /tasks/{id} : Met à jour une tâche existante.
  • DELETE /tasks/{id} : Supprime une tâche.
  • PATCH /tasks/{id}/complete : Marque une tâche comme terminée.

• Structure suggérée :

  tree

  app/  
  ├── __init__.py  
  ├── main.py          # Fichier principal  
  ├── routes/          # Fichiers contenant les endpoints  
  │   ├── __init__.py  
  │   ├── tasks.py     # Routes pour la gestion des tâches  
  ├── schemas.py       # Modèles de données avec Pydantic  
  └── database.py      # Simule une base de données (liste en mémoire ou DB réelle)  
  

🛠️ Indices

• Pour simuler une base de données, utilise une liste Python dans un premier temps.

  python

  tasks = []  
  

• Exemple de modèle avec Pydantic :

  python

  from pydantic import BaseModel  
  
  class Task(BaseModel):  
      id: int  
      title: str  
      description: str = None  
      completed: bool = False  
  

• Exemple de route pour ajouter une tâche :

  python

  @router.post("/tasks/")  
  def create_task(task: Task):  
      tasks.append(task)  
      return {"message": "Tâche ajoutée avec succès", "task": task}  
  

• Teste chaque endpoint dans Swagger UI à l'URL /docs.

🔎 Critères d'acceptation

1. Fonctionnalité complète :

   • Les fonctionnalités CRUD sont correctement implémentées.

2. Utilisation de Pydantic :

   • Les modèles sont définis avec Pydantic et validés.

3. Documentation interactive :

   • Les endpoints sont documentés automatiquement et testables dans Swagger UI.

4. Code organisé :

   • Le projet suit une structure propre avec des fichiers séparés pour les routes et les modèles.

5. Simplicité et clarté :

   • Les réponses JSON des endpoints sont claires et contiennent les informations pertinentes.

6. Versionné et documenté

   • Publier le projet sur un dépôt GitLab avec un historique de commits clair et bien documenté.
   • L'historique des commits doit refléter une progression logique du projet.
   • Ajoute un fichier README.md expliquant les étapes pour exécuter le projet et ses principales fonctionnalités.

🚀 Défi supplémentaire

Ajoute une nouvelle fonctionnalité pour trier les tâches :

• Par leur statut (completed ou non).
• Par leur titre (ordre alphabétique).