Combinez Fast API avec Django ORM

Motivation

Il semble que FastAPI se soit développé récemment avec Momentum of Breaking Bamboo.

Je veux flirter avec FastAPI de Django, mais je veux continuer à utiliser Django et son système utilisateur. Cela a l'air gourmand, mais c'est en fait une si bonne chose. Cette fois, je vais vous expliquer comment combiner Django ORM et FastAPI.

Bien sûr, il y a aussi des inconvénients. En termes de performances, le support Async IO d'ORM ne peut pas être utilisé. Si vous souhaitez améliorer les performances, vous pouvez créer un modèle tel que orm séparément.

Structure des dossiers

Parlons d'abord de la structure des dossiers. Vous pouvez créer le contenu du dossier en vous basant sur le tutoriel de la documentation Django. Pour plus de détails, voir ici.

$ django-admin startproject mysite
$ django-admin startapp poll

Après avoir généré le fichier, supprimez views.py et models.py et préparez un dossier pour FastAPI comme indiqué ci-dessous.

$ tree -L 3 -I '__pycache__|venv' -P '*.py'
.
├── manage.py
├── mysite
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── polls
    ├── __init__.py
    ├── adapters
    │   └── __init__.py
    ├── admin.py
    ├── apps.py
    ├── migrations
    │   └── __init__.py
    ├── models
    │   └── __init__.py
    ├── routers
    │   └── __init__.py
    ├── schemas
    │   └── __init__.py
    └── tests.py

7 directories, 15 files

Utilisation correcte de chaque dossier:

• dossiermodels: Django ORM
• Dossierrouters: routeurs FastAPI
• dossierschemas: validateur FastAPI Pydantic
• DossierʻAdapters`: Convertir Django ORM en validateur Pydantic

Préparez les données

Reportez-vous au Document Django et essayez d'entrer les données.

>>> from polls.models import Choice, Question
>>> from django.utils import timezone
>>> q = Question(question_text="What's new?", pub_date=timezone.now())
>>> q.save()

Introduction de FastAPI

Pour plus de simplicité, placez l'exemple ci-dessous dans le dossier «__init __. Py». Omettez également «import».

schemas

class FastQuestion(BaseModel):
    question_text: str
    pub_date: datetime

    @classmethod
    def from_model(cls, instance: Question):
        return cls(
            id=instance.id,
            question_text=instance.question_text,
            pub_date=instance.pub_date,
        )


class FastQuestions(BaseModel):
    items: List[FastQuestion]

    @classmethod
    def from_qs(cls, qs):
        return cls(items=[FastQuestion.from_model(i) for i in qs])

adapters

ModelT = TypeVar("ModelT", bound=models.Model)


def retieve_object(model_class: Type[ModelT], id: int) -> ModelT:
    instance = model_class.objects.filter(pk=id).first()
    if not instance:
        raise HTTPException(status_code=404, detail="Object not found.")
    return instance


def retrieve_question(
    q_id: int = Path(..., description="retrive question from db")
) -> Question:
    return retieve_object(Question, q_id)


def retrieve_questions():
    return Question.objects.all()

routers

@router.get("/")
def get_questions(
    questions: List[Question] = Depends(adapters.retrieve_questions),
) -> FastQuestions:
    return FastQuestions.from_qs(questions)


@router.get("/{q_id}")
def get_question(
    question: Question = Depends(adapters.retrieve_question),
) -> FastQuestion:
    return FastQuestion.from_model(question)

asgi.py

Ajout du lancement de l'application FastAPI à mysite / asgi.py.

from fastapi import FastAPI
from polls.routers import router

fastapp = FastAPI()
fastapp.include_router(router, tags=["questions"], prefix="/question")

lancement

Tout d'abord, créez un fichier statique pour ʻuvicorn`:

$ python manage.py collectstatic --noinput

FastAPI est lancé avec ʻuvicorn mysite.asgi: fastapp --reload, et Django avec ʻuvicorn mysite.asgi: application --port 8001 --reload.

Accédez à http: //127.0.0.1: 8000 / docs / pour le FastAPI Doc ethttp: //127.0.0.1: 8001 / admin /pour l'écran d'administration de Django.

Résumé

La combinaison de FastAPI et Django ORM est étonnamment facile, et si vous divisez bien la partie d'intégration, vous pouvez créer une structure de dossier soignée.

Le code ci-dessus peut être trouvé dans mon Github.