Django Modern REST : framework REST rapide

Django Modern REST : un framework API haute performance pour Django

Django Modern REST (DMR) est un framework API REST de nouvelle génération conçu pour Django — il surpasse à la fois Django REST Framework (DRF) et django-ninja en vitesse et en souplesse. Ses performances atteignent 70 % de celles de FastAPI (hors requêtes base de données). DMR prend en charge Pydantic v2, msgspec, attrs, les dataclasses, TypedDict et NamedTuple comme modèles de sérialisation. Il garantit une sécurité de typage complète, une conformité stricte à OpenAPI 3.1/3.2, et un support natif des paradigmes synchrone et asynchrone.

Fonctionnalités clés

DMR assure une compatibilité totale avec l’écosystème Django : les contrôleurs héritent de la classe View de Django, et les plugins standards fonctionnent immédiatement. Il intègre la négociation de contenu (JSON/msgpack), le streaming via SSE et JSON Lines, ainsi qu’une validation stricte des schémas de réponse en mode développement.

• Vitesse : Les benchmarks confirment que DMR devance tous les frameworks Django existants.
• Souplesse des sérialiseurs : Choisissez vos sérialiseurs au niveau du contrôleur — et intégrez éventuellement ceux de DRF.
• Sécurité de typage : Typage complet et rigoureux, aussi bien pour les requêtes que pour les réponses.
• OpenAPI : Génération automatique et moderne des schémas OpenAPI 3.1/3.2.
• Tests : Intégration native avec schemathesis, polyfactory et un plugin pytest dédié aux tests basés sur les propriétés.

Les contrôleurs orientés objet simplifient la réutilisation de code et l’extensibilité via plugins.

Application minimale opérationnelle

Une API entièrement fonctionnelle en seulement 71 lignes :

import secrets
import sys
import uuid

import pydantic
from django.conf import settings
from django.core.management import execute_from_command_line
from django.urls import include

from dmr import Body, Controller
from dmr.openapi import build_schema
from dmr.openapi.views import OpenAPIJsonView, SwaggerView
from dmr.plugins.pydantic import PydanticSerializer
from dmr.routing import Router, path

if not settings.configured:
    settings.configure(
        ROOT_URLCONF=__name__,
        ALLOWED_HOSTS='*',
        DEBUG=True,
        INSTALLED_APPS=['dmr', 'django.contrib.staticfiles'],
        STATIC_URL='/static/',
        STATICFILES_FINDERS=[
            'django.contrib.staticfiles.finders.AppDirectoriesFinder',
        ],
        TEMPLATES=[
            {
                'APP_DIRS': True,
                'BACKEND': 'django.template.backends.django.DjangoTemplates',
            },
        ],
        SECRET_KEY=secrets.token_hex(),
    )


class UserCreateModel(pydantic.BaseModel):
    email: str


class UserResponseModel(UserCreateModel):
    uid: uuid.UUID


class UserController(Controller[PydanticSerializer]):
    async def post(
        self,
        parsed_body: Body[UserCreateModel],
    ) -> UserResponseModel:
        return UserResponseModel(uid=uuid.uuid4(), email=parsed_body.email)


router = Router(
    'api/',
    [
        path('user/', UserController.as_view(), name='users'),
    ],
)
schema = build_schema(router)

urlpatterns = [
    path(router.prefix, include((router.urls, 'your_app'), namespace='api')),
    path('docs/openapi.json/', OpenAPIJsonView.as_view(schema), name='openapi'),
    path('docs/swagger/', SwaggerView.as_view(schema), name='swagger'),
]

if __name__ == '__main__':
    execute_from_command_line(sys.argv)

Exécutez avec python fichier.py runserver. La documentation Swagger est accessible à l’adresse /docs/swagger/.

Comparaison avec les concurrents

DRF souffre d’un seul sérialiseur partagé entre requêtes et réponses, de fuites involontaires de champs de modèle, et d’un support limité du typage. django-ninja repose sur le routage fonctionnel, impose Pydantic exclusivement et offre peu de personnalisation OpenAPI.

| Fonctionnalité | DRF | django-ninja | DMR |

|----------------|-----|----------------|-----|

| Sécurité de typage | Aucune | Partielle | Complète |

| Vitesse | Faible | Moyenne | Élevée |

| Support OpenAPI | Via extensions tierces | Limité | Natif OpenAPI 3.1/3.2 |

| Souplesse | Faible | Moyenne | Élevée |

DMR résout les points faibles architecturaux de Django en adoptant des modèles modernes — comme ceux utilisés dans le [modèle wemake-django-template](https://github.com/wemake-services/wemake-django-template).

Python moderne et prise en charge du multithreading

Avec l’arrivée du free-threading dans CPython, la domination d’asyncio s’estompe. Comme le soulignent les principaux développeurs Python :

• Guido van Rossum : « L’intégration d’asyncio dans la bibliothèque standard a figé l’innovation écosystémique. »
• Mark Shannon : « Les threads virtuels offrent une ergonomie supérieure à async/await. »
• Armin Ronacher : « Dans les langages disposant d’un vrai multithreading, les threads surpassent systématiquement l’asynchrone. »

Contrairement à FastAPI, Django (et donc DMR) prend en charge à la fois les paradigmes synchrone et asynchrone, sans verrouillage technologique.

Outils pour développeurs

• Tests : schemathesis permet des tests API basés sur les propriétés couvrant ~90 % des endpoints ; polyfactory génère automatiquement des jeux de données réalistes.
• Intégration IA : Modèles de prompts prêts à l’emploi pour LLM (llms-full.txt), Context7, DeepWiki et des templates centrés sur les migrations.
• Validation : Validation stricte des schémas en développement ; paramétrable par environnement en production.

Le framework est entièrement documenté, rigoureusement typé et ne contient aucun code généré par une IA.

Pourquoi cela compte

• Des performances proches de FastAPI — avec une compatibilité totale avec Django.
• Plusieurs moteurs de sérialisation — zéro verrouillage fournisseur vers une seule bibliothèque.
• Des contrôleurs orientés objet pour une réutilisation propre et des écosystèmes de plugins.
• Un support natif d’OpenAPI 3.1/3.2 et une validation stricte des schémas en phase de développement.
• Des outils intégrés pour des tests API robustes et basés sur les propriétés.

— Editorial Team