Django Modern REST: framework REST rápido

Django Modern REST: Un framework de API de alto rendimiento para Django

Django Modern REST (DMR) es un framework de API REST de nueva generación diseñado específicamente para Django, que supera tanto a Django REST Framework (DRF) como a django-ninja en velocidad y flexibilidad. Su rendimiento se acerca al 70 % del de FastAPI (excluyendo consultas a bases de datos). DMR admite Pydantic v2, msgspec, attrs, dataclasses, TypedDict y NamedTuple como modelos de serialización. Ofrece seguridad de tipos completa, cumplimiento total con OpenAPI 3.1/3.2 y soporte nativo para entornos síncronos y asíncronos.

Características clave

DMR mantiene compatibilidad total con el ecosistema Django: los controladores heredan de la clase View de Django y los plugins estándar funcionan sin modificaciones. Incluye negociación de contenido para JSON y msgpack, transmisión mediante SSE y JSON Lines, y validación estricta de esquemas de respuesta en modo desarrollo.

• Velocidad: Las pruebas comparativas confirman que DMR lidera a todos los frameworks basados en Django.
• Flexibilidad de serializadores: Elige el serializador a nivel de controlador —y opcionalmente integra serializadores de DRF.
• Seguridad de tipos: Tipado completo y riguroso tanto para cargas útiles de solicitud como para respuestas.
• OpenAPI: Generación automática y avanzada de esquemas OpenAPI 3.1/3.2.
• Pruebas: Integración nativa con schemathesis, polyfactory y un plugin de pytest para pruebas basadas en propiedades.

Los controladores basados en clases simplifican la reutilización de código y la extensibilidad mediante plugins.

Aplicación mínima funcional

Una API completamente operativa en solo 71 líneas:

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)

Ejecútala con python archivo.py runserver. La documentación de Swagger estará disponible en /docs/swagger/.

Comparación con competidores

DRF sufre de usar un único serializador para solicitudes y respuestas, filtración accidental de campos de modelos y soporte débil de tipado. django-ninja depende de rutas basadas en funciones, impone exclusivamente Pydantic y ofrece personalización limitada de OpenAPI.

| Característica | DRF | django-ninja | DMR |

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

| Seguridad de tipos | Ninguna | Parcial | Completa |

| Velocidad | Baja | Media | Alta |

| Soporte OpenAPI | Mediante plugins de terceros | Limitado | Soporte nativo OpenAPI 3.1/3.2 |

| Flexibilidad | Baja | Media | Alta |

DMR resuelve puntos críticos arquitectónicos en Django adoptando patrones modernos —como los usados en la [plantilla wemake-django-template](https://github.com/wemake-services/wemake-django-template).

Soporte para Python moderno y concurrencia

Con la llegada del free-threading a CPython, el dominio de asyncio va decayendo. Como observan desarrolladores centrales de Python:

• Guido van Rossum: «asyncio en la biblioteca estándar ha congelado la innovación del ecosistema».
• Mark Shannon: «Los hilos virtuales ofrecen una experiencia más intuitiva que async/await».
• Armin Ronacher: «En lenguajes con hilos reales, estos superan sistemáticamente a las soluciones asíncronas».

A diferencia de FastAPI, Django (y por tanto DMR) soporta ambos paradigmas —síncrono y asíncrono— sin imponer bloqueos tecnológicos.

Herramientas para desarrolladores

• Pruebas: schemathesis permite pruebas basadas en propiedades que cubren ~90 % de los endpoints; polyfactory genera automáticamente datos realistas para pruebas.
• Integración con IA: Incluye plantillas listas para usar con modelos de lenguaje grande (llms-full.txt), Context7, DeepWiki y plantillas centradas en migraciones.
• Validación: Validación estricta de esquemas en desarrollo; configurable por entorno en producción.

El framework está completamente documentado, rigurosamente tipado y no contiene código generado por IA.

¿Por qué es relevante?

• Rendimiento cercano al de FastAPI —con compatibilidad total con Django.
• Múltiples motores de serialización —sin dependencia forzosa de una única biblioteca.
• Controladores basados en clases para reutilización limpia y ecosistemas de plugins.
• Soporte nativo de OpenAPI 3.1/3.2 y validación estricta de esquemas en tiempo de desarrollo.
• Herramientas integradas para pruebas robustas basadas en propiedades.

— Editorial Team