Lewati ke isi

permintaan

Anda dapat menggunakan model Ormar sebagai pengganti model Pydantic dalam parameter tubuh permintaan FastAPI.

Anda juga dapat mencampur ormar. Model dengan pydantic jika perlu.

Salah satu tugas paling umum dalam sebuah permintaan adalah mengecualikan bidang tertentu yang tidak ingin Anda sertakan dalam muatan yang di kirim ke API.

Ini dapat dicapai dengan berbagai cara di Ormar, sehingga Anda dapat meninjau opsi Anda di bawah ini dan memilih salah satu yang paling sesuai dengan situasi Anda.

Kecualikan bidang dari permintaan

bidang opsional

Harap dicatat bahwa setiap bidang opsional tidak diperlukan, yang berarti bidang opsional dapat dilewati baik dalam tanggapan maupun permintaan.

Bidang tidak diperlukan jika (ada / banyak / semua) hal berikut terjadi:

  • Bidang ditandai sebagai nullable = Benar
  • Bidang memiliki nilai default atau fungsionalitas yang disediakan, yaitu default = "Uji"
  • Bidang mengatur server\ _ nilai default
  • Field adalah bidang autoincrement=Trueprimary\ _ key (note ormar. Integerprimary\ _ key default adalah autoincrement)

Contoh:

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

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

    Id: int = ormar. Integer (primary _ key = Benar)
    Email: str = ormar. String (max _ length = 255)
    Kata sandi: str = ormar. String (max _ length = 255)
    first _ name: str = ormar. String (max _ length = 255, nullable = Benar)
    Nama belakang: str = ormar. String (max _ length = 255)
    Kategori: str = ormar. String (max _ length = 255, default = "Pengguna")

Pada contoh di atas, id bidang (yang merupakan bilangan bulat peningkatan otomatis), nama depan (yang memiliki nullable = Benar), dan kategori (yang memiliki nilai default) adalah opsional, dapat dilewati dalam respons, dan model akan tetap divalidasi.

Jika bidang tersebut dapat dibatalkan, tidak harus dimasukkan dalam muatan selama pembuatan dan sebagai tanggapan, jadi menurut contoh di atas, Anda dapat:

!!! Peringatan Perhatikan bahwa meskipun Anda tidak harus melewati bidang opsional, Anda masih dapat melakukannya. Jika seseorang melewati nilai, itu akan digunakan nanti, kecuali jika Anda mengambil langkah-langkah untuk mencegahnya.

1
2
3
4
# perhatikan bahwa aplikasi tersebut adalah aplikasi FastApi
@app.post ("/ user /," respon _ model = User) # di sini kita menggunakan ormar. Model sebagai respon
Async def create _ user (user: User): # di sini kami menggunakan ormar. Model dalam parameter permintaan
    Kembali menunggu user.save

Ini berarti bahwa jika Anda tidak lulus ie first\ _ name dalam permintaan, itu akan divalidasi dengan benar (karena bidang ini opsional) dan Tidak ada yang akan disimpan dalam database.

Menghasilkan model pydantic dari ormar. Model

Karena tugas mengecualikan bidang sangat umum, Ormar memiliki cara khusus untuk menghasilkan model Pydantic dari Ormar yang ada. Model tanpa harus masuk kembali ke semua bidang.

Metode ini adalah metode get\ _ pydantic () yang tersedia untuk semua kelas model.

1
2
3
4
5
6
# hasilkan pohon model tanpa kata sandi pada Pengguna dan tanpa prioritas pada Kategori bersarang
PersyaratPengguna = User. get _ pydantic (kecualikan = {"password":..., "kategori":{"priority"}})
@app.post ("/ users3 /," respon _ model = Pengguna) # di sini Anda juga dapat menggunakan baik ormar / pydantic
Async def create _ user3 (pengguna: PersyaratPengguna): # gunakan model yang dihasilkan di sini
    # perhatikan bagaimana sekarang pengguna berbentuk pydantic dan bukan ormar Model sehingga Anda perlu mengonversi
    Kembali menunggu Pengguna (* * pengguna. model _ dump ()).simpan ()

!!! Catatan Untuk melihat lebih banyak contoh dan baca lebih lanjut, kunjungi bagian\ _ pydantic dokumentasi.

PERINGATAN Metode get\ _ pydantic menghasilkan semua model di pohon model bersarang berdasarkan algoritma yang memungkinkan menghindari loop dalam model (algoritma yang sama yang digunakan dalam model\ _ dump (), pilih\ _ semua (), dll.)

1
2
3
Itu berarti bahwa model bersarang tidak akan memiliki referensi ke model induk (secara default hubungan ormar adalah dua arah).

Perhatikan juga bahwa jika model yang diberikan ada di pohon lebih dari sekali, itu akan digandakan dalam model pydantic (setiap kejadian akan memiliki model sendiri yang terpisah).

Dengan begitu Anda dapat mengecualikan / memasukkan ladang yang berbeda pada daun pohon yang berbeda.

MyPy dan ketik memeriksa

Harap dicatat bahwa menetapkan fungsi sebagai tipe Python lulus pada runtime (karena tidak dicentang), dan catur tipe statis seperti MyPy mengeluh.

Meskipun hasil dari panggilan fungsi selalu sama untuk model tertentu, jenis yang dibuat secara dinamis tidak diperbolehkan.

Jadi Anda memiliki dua opsi:

Yang pertama adalah hanya menambahkan # ketik: abaikan untuk melewatkan pengecekan

1
2
3
4
5
PersyaratPengguna = User. get _ pydantic (kecualikan = {"password":..., "kategori":{"priority"}})
@app.post ("/ users3 /," respon _ model = Pengguna)
Async def create _ user3 (pengguna: Wajib Pengguna): # ketik: abaikan
    # perhatikan bagaimana sekarang pengguna bukan Model ormar jadi Anda perlu mengonversi
    Kembali menunggu Pengguna (* * pengguna. model _ dump ()).simpan ()

Yang kedua sedikit lebih hacky, menggunakan FastAPI untuk mengekstrak parameter fungsi.

Anda dapat mengesampingkan\ __anotasi_\ _ entri untuk parameter tertentu.

1
2
3
4
5
6
7
8
PersyaratPengguna = User. get _ pydantic (kecualikan = {"password":..., "kategori":{"priority"}})
# jangan gunakan dekorator aplikasi
Async def create _ user3 (pengguna: Pengguna): # gunakan model ormar di sini
    Kembali menunggu Pengguna (* * pengguna. model _ dump ()).simpan ()
# menimpa entri anotasi fungsi untuk params pengguna dengan model yang dihasilkan
buat _ user3 _ _ anotasi _ _ ["pengguna"] = Diperlukan Pengguna
# fungsi aplikasi panggilan manual (app.get, app.post dll.) dan lulus referensi fungsi Anda
app.post ("/ kategori /," respons _ model = Pengguna) (buat _ user3)

Perhatikan bahwa ini akan menyebabkan mypy "berpikir" bahwa pengguna adalah model ormar, tetapi karena itu tidak masalah dalam permintaan (Anda tetap akan memberikan dekrit jsonized dan perlu mengonversi sebelum menyimpan).

Ini harus tetap bekerja dengan baik karena model yang dihasilkan akan menjadi bagian dari bidang, sehingga semua bidang yang diperlukan akan divalidasi, dan semua bidang yang tidak digunakan akan gagal pada saat runtime.

Model kantilever independen

Solusi terakhir adalah membuat model Pydantic yang terpisah secara manual. Ini bekerja persis seperti aplikasi FastAPI normal, sehingga Anda dapat menggunakan model respons dan permintaan yang berbeda, dll.

Contoh:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
Impor pydantic

UserBuat Kelas (pydantic. BaseModel):
    model _ config = pydantic. ConfigDict (dari _ atribut = Benar)

    Email: str
    nama _ depan: str
    Nama _ belakang: str
    Kata sandi: str


@app.post ("/ users3 /," respons _ model = Pengguna) # gunakan model ormar di sini (tapi tentu saja Anda BISA menggunakan pydantic juga di sini)
Async def membuat _ user3 (pengguna: UserBuat): # gunakan model pydantic di sini
    # perhatikan bagaimana sekarang permintaan param adalah model pydantic dan bukan yang ormar
    # jadi Anda perlu mengurai / mengubahnya menjadi ormar sebelum Anda dapat menggunakan database
    Kembali menunggu Pengguna (* * pengguna. model _ dump ()).simpan ()