Django Modern REST: szybki REST framework

Django Modern REST: nowoczesny, wydajny framework do budowy API w Django

Django Modern REST (DMR) to framework do tworzenia interfejsów API REST oparty na Django, który przewyższa DRF i django-ninja pod względem wydajności i elastyczności. Jego szybkość jest o 30% mniejsza niż FastAPI — bez uwzględnienia zapytań do bazy danych. Obsługuje modele serializacji oparte na Pydantic v2, msgspec, attrs, dataclasses, TypedDict oraz NamedTuple. Pełna typizacja, obsługa OpenAPI 3.1/3.2 oraz tryby synchroniczny i asynchroniczny.

Kluczowe funkcje

Framework zachowuje pełną zgodność z ekosystemem Django: kontrolery dziedziczą po klasie View, a standardowe wtyczki działają bez modyfikacji. Obsługa content negotiation dla JSON/msgpack oraz strumieniowania przez SSE/JsonLines. W trybie deweloperskim — ścisła walidacja schematów odpowiedzi.

• Wydajność: benchmarki potwierdzają pozycję lidera wśród frameworków Django.
• Elastyczność serializatorów: wybór serializatora na poziomie kontrolera; możliwa integracja serializatorów DRF.
• Typizacja: kompleksowa, bez kompromisów — zarówno dla request.data, jak i odpowiedzi.
• OpenAPI: automatyczna generacja nowoczesnych, aktualnych schematów.
• Testowanie: integracja z schemathesis, polyfactory oraz wtyczką pytest do testów opartych na własnościach (property-based).

Architektura oparta na klasach-kontrolerach ułatwia ponowne wykorzystanie kodu i rozbudowę za pomocą wtyczek.

Minimalna aplikacja

Przykład pełnoprawnego API uruchamianego w 71 liniach kodu:

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)

Uruchomienie: python file.py runserver. Dokumentacja Swagger dostępna pod adresem /docs/swagger/.

Porównanie z konkurencją

DRF cierpi na brak elastyczności: jeden serializator dla żądań i odpowiedzi, wycieki pól modeli, brak typizacji. django-ninja opiera się wyłącznie na funkcjach (nie klasach), jest sztywno powiązany z Pydantic i oferuje ograniczoną dostosowalność OpenAPI.

| Aspekt | DRF | django-ninja | DMR |

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

| Typizacja | Brak | Częściowa | Pełna |

| Wydajność | Niska | Średnia | Wysoka |

| OpenAPI | Przez wtyczki | Ograniczona | Natywna obsługa 3.1/3.2 |

| Elastyczność | Niska | Średnia | Wysoka |

DMR rozwiązuje problemy architektoniczne Django dzięki wzorcom takim jak wemake-django-template.

Obsługa nowoczesnego Pythona

Z wprowadzeniem Free-Threading w CPython asyncio traci na znaczeniu. Cytat od głównych deweloperów:

• Guido van Rossum: „Obecność asyncio w bibliotece standardowej spowolniła rozwój alternatywnych rozwiązań.”
• Mark Shannon: „Wirtualne wątki są lepszym rozwiązaniem niż async/await.”
• Armin Ronacher: „Wątki wygrywają z async w językach obsługujących prawdziwe wątki.”

Django wspiera oba podejścia — bez konieczności zależności od asyncio, w przeciwieństwie do FastAPI.

Narzędzia deweloperskie

• Testowanie: schemathesis do testów opartych na własnościach pokrywa 90% API. Polyfactory generuje realistyczne dane testowe.
• Integracje AI: pliki llms-full.txt, Context7, DeepWiki oraz gotowe prompty do migracji bazodanowych.
• Walidacja: ścisła w trybie deweloperskim, elastyczna w środowisku produkcyjnym.

Framework jest dobrze udokumentowany, w pełni typizowany i nie zawiera kodu wygenerowanego przez AI.

Co warto zapamiętać

• Wydajność zbliżona do FastAPI przy pełnej zgodności z Django.
• Obsługa wielu serializatorów — bez wymuszania jednego rozwiązania.
• Kontrolery jako klasy — ułatwiają ponowne wykorzystanie i rozbudowę wtyczkami.
• Pełna obsługa OpenAPI 3.1/3.2 oraz ścisła walidacja schematów w trybie deweloperskim.
• Zaawansowane narzędzia do testów opartych na własnościach (property-based testing) dla API.

— Editorial Team