Créer une API REST en Python

BROUILLON EN COURS DE REDACTION, REVENIR SUR SYNTAXE FAUTES

Qu'est-ce qu'une API ?

Une API (Application Programming Interface, ou Interface de Programmation d'Application) est un ensemble de protocoles qui permet à des logiciels de communiquer entre eux. Elle reçoit des requêtes, les transmet à un système pour les traiter et renvoie une réponse.

Les API permettent d'interagir avec des services web, des applications externes et des bases de données. En Python, il est facilement possible de développer ses propres APIs.

Imaginez que vous êtes chercheur dans une bibliothèque. La bibliothèque, avec ses milliers de livres, représente une base de données avec des milliers d'informations. Vous avez à disposition le catalogue de la bibliothèque qui représente la documentation de l'API. Enfin, la bibliothécaire est l'API. Vous lui soumettez une demande précise, elle va chercher l'information et vous la rapporte.

Vous obtenez l'information souhaitée sans avoir besoin de comprendre tout le système de rangement. L'API est donc structurée et sécurisée.

Pourquoi utiliser des APIs en Python ?

Python est très populaire pour développer ou utiliser des APIs.

Quelques avantages à utiliser une API

Accéder à des données externes : une application frontend qui récupère les informations d'une base de données via une API
Intégrer des services : système de paiement sur son application, envoi d'emails, etc
Automatiser des tâches : publier du contenu sur les réseaux de manière automatique, créer une carte sur Trello depuis sa propre application

Exemple : Utiliser une API REST en Python

L'un des types d'API les plus courants est l'API REST (Representational State Transfer).

Une API REST est un style d'architecture logicelle. Une API est considérée comme RESTful si elle respecte un ensemble de contraintes :

Elle utilise les méthodes HTTP standards (GET, POST, PUT, DELETE)
Elle est sans état. Ce qui signifie que le serveur ne mémorise aucune information sur le client entre deux requêtes. Chaque demande est traitée de manière indépendante

Il existe d'autres types d'APIs comme SOAP et GraphQL.

Utilisons la bibliothèque requests pour interroger l'API de The Movie Database.
Dans cet exemple, nous allons récupérer la liste des films actuellement à l'affiche. Pour cela, on utilise un endpoint de l'API, mais il faut d'abord s'authentifier avec un token que vous pouvez récupérer facilement sur votre espace.

# Il faut d'abord installer la bibliothèque si ce n'est pas déjà fait :
# pip install requests

import requests
import json

# 1. Définir l'URL et les en-têtes (headers) pour l'authentification
url = "https://api.themoviedb.org/3/movie/now_playing?language=en-US&page=1"
headers = {
    "accept": "application/json",
    # ATTENTION : Remplacez "VOTRE_TOKEN" par votre véritable jeton d'accès TMDB
    "Authorization": "Bearer VOTRE_TOKEN"
}

# 2. Envoyer la requête GET
response = requests.get(url, headers=headers)

# 3. Vérifier si la requête a réussi (code de statut 200 signifie "OK")
if response.status_code == 200:
    # 4. Extraire les données et afficher les 5 premiers films
    movies_data = response.json()
    print("Voici les 5 premiers films actuellement à l'affiche :")
    for movie in movies_data['results'][:5]:
        print(f"- Titre: {movie['title']}, Date de sortie: {movie['release_date']}")
else:
    # Si la requête échoue, afficher le code de statut et le message d'erreur
    print(f"La requête a échoué. Code de statut : {response.status_code}")
    print(f"Message : {response.text}")


                PYTHON
            

Créer ses propres APIs en Python

Consommer des APIs c'est bien, mais créer son API c'est encore mieux ! 😎
Ainsi, d'autres applications (mobile, front-end, backend, etc.) peuvent interagir avec vos données. Python compte plusieurs frameworks pour développer ses APIs.

Django REST framework (DRF)

Construit sur le framework Django, DRF est une solution robuste et "tout compris". Il est donc idéal pour les projets complexes qui nécessitent un back-office, une authentification intégrée et son ORM ultra complet.

Par exemple, avec DRF on définit comment les données sont converties en JSON (le sérialiseur), puis comment la requête est gérée (la vue).

Exemple

Le modèle définit la structure de nos données dans la base de données

# models.py
from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=200)
    completed = models.BooleanField(default=False)

    def __str__(self):
        return self.title


                PYTHON
            

Le sérialiseur convertit les objets Django en format JSON et inversement

# serializers.py
from rest_framework import serializers
from .models import Task

class TaskSerializer(serializers.ModelSerializer):
    class Meta:
        model = Task
        fields = ['id', 'title', 'completed']


                PYTHON
            

Le ModelViewSet fournit automatiquement toute la logique des opérations CRUD (Create, Read, Update, Delete)

# views.py
from rest_framework import viewsets
from .models import Task
from .serializers import TaskSerializer

class TaskViewSet(viewsets.ModelViewSet):
    """
    ViewSet qui fournit automatiquement les actions :
    list, create, retrieve, update, destroy
    """
    queryset = Task.objects.all()
    serializer_class = TaskSerializer


                PYTHON
            

Le router se charge de générer les URLs de votre API

# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import TaskViewSet

router = DefaultRouter()
router.register(r'tasks', TaskViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
]


                PYTHON
            

FastAPI

FastAPI est un framework reconnu pour ses performances et sa simplicité. De plus, la documentation interactive de votre API se génère automatiquement. Il intègre la bibliothèque Pydantic pour la validation des données.

Exemple

BaseModel de Pydantic sert à définir la structure des données pour l'utilisateur dans ce cas. Si on envoie un âge qui n'est pas un entier ou un email qui n'est pas valide, FastAPI renverra une erreur claire
Le décorateur@app.post("/users/") indique que l'on peut envoyer une requête POST sur l'URL /users/
En typant le paramètre user avec la classe User (def create_user(user: User):), FastAPI valide les données de la requête et les convertit en un objet User

# Installation nécessaire :
# pip install fastapi "uvicorn[standard]"

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()

# Définir un modèle Pydantic pour valider les données entrantes
class User(BaseModel):
    name: str
    email: EmailStr
    age: int
    bio: str | None = None

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

# Définir un endpoint pour créer un utilisateur (méthode POST)
@app.post("/users/")
def create_user(user: User):
    # FastAPI valide automatiquement les données reçues
    # par rapport au modèle User.
    return {
        "message": "Utilisateur créé avec succès",
        "user": user.model_dump()
    }

# Pour lancer le serveur, on utiliserait la commande dans le terminal :
# uvicorn nom_du_fichier:app --reload


                PYTHON
            

Et bien d'autres

Il existe d'autres frameworks pour développer vos propres APIs. Et comment ne pas citer Flask, connu pour sa flexibilité. Il fournit une base et possède plusieurs extensions pour ajouter des fonctionnalités comme Flask-RESTful. Vous avez donc un contrôle total sur votre application.

Django, FastAPI, Flask sont les frameworks les plus connus dans ce domaine. Mais il existe d'autres frameworks comme Litestar, Falcon, ou Starlette.