Django Modern REST: schnelles REST-Framework

Django Modern REST: Ein Hochleistungs-API-Framework für Django

Django Modern REST (DMR) ist ein modernes REST-API-Framework für Django – schneller und flexibler als Django REST Framework (DRF) und django-ninja. Es erreicht eine Performance, die innerhalb von 30 % von FastAPI liegt (ohne Datenbankabfragen). DMR unterstützt Pydantic v2, msgspec, attrs, dataclasses, TypedDict und NamedTuple als Serialisierungsmodelle. Das Framework bietet vollständige Typsicherheit, Konformität mit OpenAPI 3.1/3.2 und nahtlose Unterstützung für synchrone und asynchrone Anwendungen.

Kernfunktionen

DMR ist vollständig in das Django-Ökosystem integriert: Controller erben von Djangos View, und gängige Django-Plugins funktionieren sofort ohne Anpassung. DMR bietet Content-Negotiation für JSON und MsgPack, Streaming über Server-Sent Events (SSE) und JSON Lines sowie strenge Validierung der Antwort-Schemata im Entwicklungsmodus.

• Geschwindigkeit: Benchmarks bestätigen, dass DMR alle Django-basierten Frameworks übertrifft.
• Serializer-Flexibilität: Wahl des Serialisierers auf Controllerebene – optional auch DRF-Serialisierer integrierbar.
• Typsicherheit: Vollständige, unverzichtbare Typannotationen für Anfrage- und Antwort-Daten.
• OpenAPI: Automatische, zukunftsorientierte Generierung von OpenAPI 3.1/3.2-Schemata.
• Testunterstützung: Native Integration mit schemathesis, polyfactory und einem pytest-Plugin für property-based Testing.

Klassenbasierte Controller vereinfachen Wiederverwendung und Erweiterbarkeit durch Plugins.

Minimalbeispiel

Eine voll funktionsfähige API in nur 71 Zeilen:

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)

Starten Sie die Anwendung mit python file.py runserver. Die Swagger-Dokumentation ist unter /docs/swagger/ erreichbar.

Vergleich mit Konkurrenzframeworks

DRF leidet unter einem einzigen Serializer für Anfragen und Antworten, unbeabsichtigter Offenlegung von Modellfeldern und schwacher Typunterstützung. django-ninja setzt ausschließlich auf funktionsbasiertes Routing, erzwingt Pydantic und bietet nur begrenzte OpenAPI-Anpassungsmöglichkeiten.

| Funktion | DRF | django-ninja | DMR |

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

| Typsicherheit | Keine | Teilweise | Vollständig |

| Geschwindigkeit | Niedrig | Mittel | Hoch |

| OpenAPI-Unterstützung | Über Drittanbieter-Plugins | Eingeschränkt | Native OpenAPI 3.1/3.2 |

| Flexibilität | Niedrig | Mittel | Hoch |

DMR löst architektonische Schwachstellen in Django durch moderne Muster – wie sie bereits im [wemake-django-template](https://github.com/wemake-services/wemake-django-template) eingesetzt werden.

Moderne Python- und Thread-Unterstützung

Mit dem bevorstehenden Free-Threading in CPython verliert asyncio an Dominanz. Wie führende Python-Entwickler betonen:

• Guido van Rossum: „asyncio in der Standardbibliothek hat die Innovationskraft des Ökosystems eingefroren.“
• Mark Shannon: „Virtuelle Threads bieten bessere Ergonomie als async/await.“
• Armin Ronacher: „In Sprachen mit echtem Multithreading schneiden Threads stets besser ab als asynchrone Lösungen.“

Im Gegensatz zu FastAPI unterstützt Django – und damit auch DMR – sowohl synchrone als auch asynchrone Paradigmen, ohne in eine Richtung festgelegt zu sein.

Entwickler-Tooling

• Testing: schemathesis ermöglicht property-based API-Tests für rund 90 % aller Endpunkte; polyfactory generiert automatisch realistische Testdaten.
• KI-Integration: Enthält sofort einsatzbereite LLM-Prompts (llms-full.txt), Context7, DeepWiki sowie Vorlagen speziell für Migrationen.
• Validierung: Strenge Schema-Validierung im Entwicklungsmodus; konfigurierbar pro Umgebung in Produktion.

Das Framework ist umfassend dokumentiert, strikt typisiert und enthält keinerlei KI-generierten Code.

Warum DMR wichtig ist

• Nahezu FastAPI-Performance – bei vollständiger Django-Kompatibilität.
• Mehrere Serialisierungs-Backends – keine Abhängigkeit von einer einzigen Bibliothek.
• Klassenbasierte Controller für klare Wiederverwendbarkeit und ein reichhaltiges Plugin-Ökosystem.
• Native OpenAPI 3.1/3.2-Unterstützung und strenge Schema-Validierung während der Entwicklung.
• Integrierte Tools für robuste, property-based API-Tests.

— Editorial Team