Ga naar inhoud

Snelle API

Ormar combineren met FastAPI is heel eenvoudig.

Afgezien van het verbinden met de database bij het opstarten, hoeft u alleen maar het Pydantic-model te vervangen door het Ormar-model.

Hier vindt u een zeer eenvoudige voorbeeldapplicatiecode.

!!! Waarschuwing In dit voorbeeld wordt ervan uitgegaan dat u al een database hebt gemaakt. Als dit niet het geval is, gaat u naar de sectie Database Initialization.

!!!De volgende voorbeelden (alle onderdelen) moeten in één bestand worden geplaatst.

1
Het is voor de duidelijkheid onderverdeeld in subsecties.

!!!Opmerking Als u meer wilt weten over het gebruik van het Ormar-model in FastAPI-verzoeken en -reacties, bekijk dan de documentatie over antwoorden en verzoeken.

Snel aan de slag

!!!Merk op dat u het volledige snelstartscript kunt vinden onder de voorbeelden in de github-repository.

Import en initialisatie

Gebruik de Fast API-levenscyclus om start- en sluitprogramma 's te definiëren en deze in applicaties te gebruiken.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Lijst van het typen van import, optioneel

Databanken importeren
Sqlalchemie invoeren
FastAPI importeren vanuit fastAPI

Ormar importeren

Vanuit contextlib importeren asynccontextmanager
FastAPI importeren vanuit fastAPI


@ asynccontextmanager
Async def levensduur (_: FastAPI) - > AsyncIterator [Geen]:
    Indien niet config.Database.is _ connected:
        Wacht op config.Database.connect ()

    Opbrengst

    Als config.Database.is _ connected:
        Wacht op config.database .disconnect ()


basis _ ormar _ config = ormar. OrmarConfig (
    Metadata = sqlalchemie. MetaData (),
    Database = databanken. Database ("sqlite: / / test.db"),
)
App = FastAPI (levensduur = levensduur (basis _ ormar _ config))

Info

Model definitie

Definieer het ormatiemodel met de juiste velden.

Deze modellen worden gebruikt in plaats van het Pydantic-model.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
basis _ ormar _ config = OrmarConfig (
    Metagegevens = metagegevens
    Database = database
)


Klasse Categorie (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)


Klasse-item (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)
    Categorie: Optioneel [Categorie] = ormar. ForeignKey (Categorie, nullable = Waar)

!!!Tip U kunt meer lezen over het definiëren van een model in de sectie Modellen.

Definitie van FastAPI-eindpunt

Definieer de eindpunten die u nodig heeft en noteer hoe het ormar-model wordt gebruikt als responsmodel en verzoekparameters.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@ App.get ("/ items /", reactie _ model = Lijst [Item])
Async def krijgen _ items ():
    Items = wachten Items selecteren _ gerelateerd ("categorie") .all ()
    Artikelen retourneren


@app.post ("/ items /", reactie _ model = Item)
Async maakt _ item aan (item: Item):
    item.save ()
    Artikel retourneren


@app.post ("/ categorieën /", reactie _ model = Categorie)
Async def create _ category (categorie: Categorie):
    category.save ()
    Retour categorie


@ App.put ("/ items /{item_id}")
Geschikt voor get _ item (item _ id: int, item: item):
    item _ db = afwachten Item.objects.get (pk = item _ id)
    Retourneren wacht op item _ db (* * item.model _ dump ())


@ App.delete ("/ items /{item_id}")
Async def delete _ item (item _ id: int, item: item = geen):
    Als item:
        Terugkeer {"deleted_rows": await item.delete()}
    item _ db = afwachten Item.objects.get (pk = item _ id)
    Terugkeer {"deleted_rows": await item_db.delete()}

!!!Merk op hoe een ormar-modelmethode zoals save () direct beschikbaar is nadat FastAPI deze voor u heeft geïnitialiseerd.

!!!Merk op dat u een model (of lijst met modellen) direct kunt retourneren - FastAPI zal het voor u jsoniseren

Test de toepassing

FastAPI wordt uitgevoerd

Als u dit script wilt uitvoeren en fastapi swagger wilt gebruiken, installeer dan eerst uvicorn

Pip installeert uvicorn

En start FastAPI.

uvicorn <filename_without_extension>:app --reload

Nu kunt u naar uw browser navigeren (het fastapi-adres is standaard 127.0.0.1:8000/docs ) en de api gebruiken.

!!!Info U kunt meer lezen over het uitvoeren van FastAPI in de FastAPI-documentatie.

Test met pytest

Hier is een voorbeeldtest die zal aantonen dat alles werkt zoals verwacht.

Zorg ervoor dat u eerst de tafel maakt. Als u pytest gebruikt, kunt u een armatuur gebruiken.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
@ Pytest.fixture (automatisch = Waar, scope = "module")
Maak _ test _ database aan ():
    Motor = sqlalchemy.create _ engine (DATABASE _ URL)
    aanmaken _ alles (engine)
    Opbrengst
    drop _ all (motor)



# hier is een voorbeeldtest om de werking van de ormar met fastapi te controleren

Vanaf starlette.testclient importeren TestClient

Def test _ alle _ eindpunten ():
    # let op dat TestClient alleen sync is, gebruik hier geen asyns
    Opdrachtgever = TestClient (app)
    # Merk op dat u handmatig verbinding moet maken met de database
    # of gebruik client als contextmanager tijdens tests
    Met cliënten als cliënten:
        Reactie = client.post ("/ categorieën /", json ={"name": "test cat"})
        Categorie = response.json ()
        Reactie = client.post (
            "/ items /", json ={"name": "test", "id": 1, "category": category}
        )
        Item = Item (* * reactie.json ())
        Beweren item.pk is geen Geen

        Reactie = client.get ("/ items /")
        Items = [Item (* * item) voor item in response.json ()]
        Gedeponeerde items [0] = = item

        item.name = "Nieuwe naam"
        Reactie = client.put (f "/ items /{item.pk}", json = item.model _ dump ())
        Bevestig antwoord.json () = = item.model _ dump ()

        Reactie = client.get ("/ items /")
        Items = [Item (* * item) voor item in response.json ()]
        Artikelen bevestigen [0]. name = = "Nieuwe naam"

        Reactie = client.delete (f "/ items /{item.pk}", json = item.model _ dump ())
        Bevestig reactie.json () .get ("verwijderde _ rijen", "_ _ UNDEFINED _ _")! = "_ _ UNDEFINED _ _"
        Reactie = client.get ("/ items /")
        Items = response.json ()
        Stel len (items) = = 0

!!!Tip Als u meer testgevallen wilt zien en hoe u ormar / fastapi kunt testen, raadpleeg dan de testmap in de github-repository

!!!Info U kunt meer lezen over het testen van FastAPI in de FastAPI-documentatie.