Lewati ke isi

API Cepat

Menggabungkan Ormar dengan FastAPI sangat sederhana.

Selain terhubung ke database saat startup, yang perlu Anda lakukan hanyalah mengganti model Pydantic dengan model Ormar.

Di sini Anda dapat menemukan contoh kode aplikasi yang sangat sederhana.

!!! Peringatan Contoh ini mengasumsikan bahwa Anda telah membuat database. Jika tidak demikian, kunjungi bagian Inisialisasi Database.

!!!Contoh berikut (semua bagian) harus di tempatkan dalam satu file.

1
Ini dibagi menjadi subbagian untuk kejelasan.

!!!Catatan Jika Anda ingin mempelajari lebih lanjut tentang cara menggunakan model Ormar dalam permintaan dan tanggapan FastAPI, lihat dokumentasi tanggapan dan permintaan.

Mulai Cepat

!!!Perhatikan bahwa Anda dapat menemukan skrip peluncuran cepat lengkap di bawah contoh di repositori github.

Impor dan inisialisasi

Gunakan siklus hidup API Cepat untuk menentukan program mulai dan tutup dan menggunakannya dalam aplikasi.

 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
Daftar dari pengetikan impor, Opsional

Basis data impor
meter persegi import
FastAPI impor dari fastAPI

Asrama impor

Dari contextlib import sebagaimanajer
FastAPI impor dari fastAPI


@ asynccontextmanager
Async def umur (_: FastAPI) - > AsyncIterator [Tidak ada]:
    Jika tidak config.Database.is _ connect:
        Tunggu konfigurasi. Database.connect ()

    Hasil

    Jika config.Database.is _ terhubung:
        Tunggu konfig.database .putuskan ()


base _ ormar _ config = ormar. OrmarConfig (
    Metadata = sqlalchemy. MetaData (),
    Database = database. Database ("sqlite: / / test.db"),
)
Aplikasi = FastAPI (umur = umur (basis _ ormar _ config))

Info

Definisi model

Tentukan model ormar dengan bidang yang sesuai.

Model ini akan digunakan sebagai pengganti model Pydantic.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
base _ ormar _ config = OrmarConfig (
    Metadata = metadata
    Basis data = basis data
)


Kategori Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)


Item Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)
    Kategori: Opsional [Kategori] = ormar. ForeignKey (Kategori, nullable = Benar)

!!!Tip Anda dapat membaca lebih lanjut tentang mendefinisikan model di bagian Model.

Definisi titik akhir FastAPI

Tentukan titik akhir yang Anda butuhkan, perhatikan bagaimana model ormar digunakan sebagai respons\ _ model dan parameter permintaan.

 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 ("/ item /," respon _ model = Daftar [Item])
Sinkronisasi pasti mendapatkan _ item ():
    Item = menunggu Item pilih _ terkait ("kategori").all ()
    Mengembalikan barang


@app.post ("/ item /," respon _ model = Barang)
Async pasti membuat _ item (item: Item):
    Tunggu item.save
    Item pengembalian


@app.post ("/ kategori /," respon _ model = Kategori)
Async def create _ category (kategori: Kategori):
    Tunggu category.save
    Kategori pengembalian


@ App.put ("/ item /{item_id}")
Async def get _ item (item _ id: int, item: Item):
    item _ db = await Item.objeks.get (pk = item _ id)
    Kembali menunggu item _ db (* * item.model _ dump ())


@ App.delete ("/ item /{item_id}")
Async def delete _ item (item _ id: int, item: Item = Tidak ada):
    Jika item:
        Kembali {"deleted_rows": await item.delete()}
    item _ db = await Item.objeks.get (pk = item _ id)
    Kembali {"deleted_rows": await item_db.delete()}

!!!Perhatikan bagaimana metode model ormar seperti save () tersedia langsung setelah FastAPI menginisialkannya untuk Anda.

!!!Perhatikan bahwa Anda dapat langsung mengembalikan model (atau daftar model) - FastAPI akan jsonize untuk Anda

Uji aplikasi

Menjalankan FastAPI

Jika kamu ingin menjalankan skrip ini dan gunakan fastapi swagger terlebih dahulu instal uvicorn

Pip memasang uvicorn

Dan mulai FastAPI.

uvicorn <filename_without_extension>:app --reload

Sekarang Anda dapat menavigasi ke browser Anda (alamat fastapi 127.0.0.1:8000/docs secara default) dan menggunakan api.

!!!Info Anda dapat membaca lebih lanjut tentang menjalankan FastAPI dalam dokumentasi FastAPI.

Tes dengan pytest

Berikut adalah contoh tes yang akan menunjukkan bahwa semuanya bekerja seperti yang diharapkan.

Pastikan untuk membuat tabel terlebih dahulu. Jika Anda menggunakan pytest, Anda dapat menggunakan perlengkapan.

 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 (autouse = Benar, scope = "modul")
Def membuat _ test _ database ():
    Mesin = sqlalchemy.create _ engine (DATABASE _ URL)
    buat _ semua (mesin)
    Hasil
    jatuhkan _ semua (mesin)



# di sini adalah tes sampel untuk memeriksa kerja ormar dengan fastapi

Dari starlette.testclient impor TestClient

Tes pasti _ semua _ titik akhir ():
    # perhatikan bahwa TestClient hanya sinkron, jangan gunakan asyns di sini
    Klien = TestClient (aplikasi)
    # perhatikan bahwa Anda perlu terhubung ke database secara manual
    # atau gunakan klien sebagaimanajer kontekstual selama tes
    Dengan klien sebagai klien:
        Response = client.post ("/ kategori /," json ={"name": "test cat"})
        Kategori = response.json ()
        Jawaban = client.post (
            "/ item /," json ={"name": "test", "id": 1, "category": category}
        )
        Item = Barang (* * response.json ())
        Tegaskan item.pk tidak ada

        Tanggapan = klien. Dapatkan ("/ item /")
        Item = [Item (* * item) untuk item dalam response.json () ]
        Item yang ditetapkan [0] = = item

        item.name = "Nama baru"
        Respon = client.put (f "/ item /{item.pk}," json = item. model _ dump ())
        Tegaskan tanggapan .json () = = item.model _ dump ()

        Tanggapan = klien. Dapatkan ("/ item /")
        Item = [Item (* * item) untuk item dalam response.json () ]
        Menegaskan item [0]. nama = = "Nama baru"

        Tanggapan = klien. Hapus (f "/ item /{item.pk}," json = item. model _ dump ())
        Tegaskan tanggapan .json ().get ("hapus _ rows," "_ _ UNDEFINED _ _")! = "_ _ UNDEFINED _ _"
        Tanggapan = klien. Dapatkan ("/ item /")
        Item = response.json ()
        Tutup len (item) = = 0

!!!Tip Jika Anda ingin melihat lebih banyak kasus tes dan cara menguji ormar / fastapi, lihat direktori tes di repositori github

!!!Info Anda dapat membaca lebih lanjut tentang pengujian FastAPI dalam dokumentasi FastAPI.