Django Modern REST: rychlý REST framework

Django Modern REST: Výkonný moderní framework pro API v Django

Django Modern REST (DMR) je framework pro tvorbu REST API na bázi Django, který překonává jak Django REST Framework (DRF), tak django-ninja co do rychlosti i flexibilitu. Jeho výkon je pouze o 30 % nižší než u FastAPI – a to bez zahrnutí času na databázové dotazy. Podporuje Pydantic v2, msgspec, attrs, dataclasses, TypedDict i NamedTuple jako modely pro serializaci. Plná typová anotace, OpenAPI 3.1/3.2, podpora synchronního i asynchronního režimu.

Klíčové vlastnosti

Framework zachovává plnou kompatibilitu s Django ekosystémem: Controller dědí z View, standardní pluginy fungují bez úprav. Obsahuje content negotiation pro JSON a msgpack, podporu streamingu přes SSE a JSON Lines. Ve vývojovém režimu probíhá striktní validace odpovědí podle schématu.

• Rychlost: benchmarky ukazují, že DMR je nejrychlejší mezi všemi Django-based frameworky.
• Flexibilita serializátorů: výběr serializátoru na úrovni kontroleru; možná integrace existujících DRF serializátorů.
• Typová bezpečnost: úplná a konzistentní pro request.data i odpovědi – žádné kompromisy.
• OpenAPI: automatická generace aktuálních, plně funkčních schémat podle specifikace 3.1/3.2.
• Testování: integrovaná podpora nástrojů jako schemathesis, polyfactory a pytest-plugin pro property-based testování.

Architektura založená na třídách kontrolerů usnadňuje opakované použití kódu i rozšiřitelnost prostřednictvím pluginů.

Minimální aplikace

Příklad plnohodnotného API v 71 řádcích kódu:

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)

Spusťte pomocí: python soubor.py runserver. Dokumentace ve Swaggeru je dostupná na /docs/swagger/.

Srovnání s konkurencí

DRF trpí jednotným serializátorem pro požadavky i odpovědi, únikem polí modelů do API a chybějící typovou anotací. Django-ninja používá funkce místo tříd, je pevně svázaný s Pydanticem a nabízí omezenou přizpůsobitelnost OpenAPI.

| Aspekt | DRF | django-ninja | DMR |

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

| Typová anotace | Chybí | Částečná | Úplná |

| Rychlost | Nízká | Střední | Vysoká |

| OpenAPI | Přes externí pluginy | Omezená | Nativní podpora 3.1/3.2 |

| Flexibilita | Nízká | Střední | Vysoká |

DMR řeší architektonické nedostatky Django pomocí osvědčených vzorů, např. podobných šabloně wemake-django-template.

Podpora moderního Pythonu

S příchodem Free-Threading v CPython ztrácí asyncio na významu. Citáty hlavních vývojářů:

• Guido van Rossum: „Přítomnost asyncio ve stdlib zpomalila vývoj alternativ.“
• Mark Shannon: „Virtual threads jsou lepší než async/await.“
• Armin Ronacher: „V jazycích s pravými vlákny vyhrávají vlákna nad asynchronním kódem.“

Django nativně podporuje oba přístupy – bez nutnosti závislosti na asyncio, na rozdíl od FastAPI.

Nástroje pro vývoj

• Testování: schemathesis pro property-based testování pokrývá až 90 % vašeho API. Polyfactory automaticky generuje testovací data.
• Integrace s AI: podpora llms-full.txt, Context7, DeepWiki a specializovaných promptů pro migrace.
• Validace: striktní ve vývojovém prostředí, flexibilní v produkčním.

Framework je plně dokumentován, typově anotován a nepoužívá kód generovaný umělou inteligencí.

Co je klíčové

• Výkon blížící se FastAPI při plné kompatibilitě s Django.
• Široká volba serializátorů – žádná závislost na jediném řešení.
• Třídy kontrolerů pro opakované použití a snadnou integraci pluginů.
• Plná podpora OpenAPI 3.1/3.2 a striktní validace schémat ve vývoji.
• Komplexní nástroje pro property-based testování API.

— Editorial Team