Lewati ke isi

membalas

Anda dapat menggunakan model ormar sebagai pengganti model pydantic dalam model respon fastapi\ _.

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

Salah satu tugas paling umum dalam tanggapan adalah mengecualikan bidang tertentu yang tidak ingin Anda sertakan dalam data respons.

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 tanggapan

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:

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 memvalidasi dengan benar (karena bidang ini opsional), simpan di database dan kembalikan catatan yang disimpan tanpa bidang ini (yang juga akan memvalidasi).

!!!Perhatikan bahwa meskipun Anda tidak lulus nilai bidang, bidang itu sendiri masih ada dalam model respons\ _, yang berarti akan muncul dalam data respons dan disetel ke Tidak Ada.

1
Jika Anda ingin sepenuhnya mengecualikan bidang dari hasil, baca terus.

Respon### FastApi\ model_\ pengecualian_

FastAPI memiliki respons\ _ model\ _ tidak termasuk yang menerima satu set (atau daftar) nama bidang.

Ini memiliki keterbatasan karena Ormar dan Pydantic juga menerima kamus di mana Anda dapat mengatur kolom pengecualian / inklusi atau pada model bersarang (lebih lanjut tentang ini di bawah).

Peringatan Perhatikan bahwa bidang yang diperlukan tidak dapat dikecualikan saat menggunakan model respons\ _, karena akan gagal selama validasi.

1
2
3
@app.post ("/ user /," respon _ model = User, respon _ model _ excde ={"password"})
Async def create _ user (pengguna: Pengguna):
    Kembali menunggu user.save

Titik akhir di atas dapat ditanyakan seperti ini:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
Dari starlette.testclient impor TestClient

Klien = TestClient (aplikasi)

Dengan klien sebagai klien:
        # catatan tidak ada pk
        Pengguna = {
            "Email": "test@domain.com,"
            "Kata Sandi": "^*^% A*DA * IAAA,"
            "nama depan": "John,"
            "nama belakang": "Doe,"
        }
        Response = client.post ("/ user /," json = user)
        # perhatikan bahwa bidang yang dikecualikan sepenuhnya hilang dari respons
        Tegaskan "kata sandi" tidak dalam response.json ()
        # membaca tanggapan dan menginisialisasi model dari itu
        dibuat _ user = Pengguna (* * response.json ())
        # note pk dihuni oleh autoincrement
        Tegaskan created_user.pk tidak ada
        # perhatikan bahwa kata sandi juga hilang dalam model yang diinisialisasi
        Tegaskan dibuat _ kata sandi pengguna Tidak Ada

Perhatikan bagaimana bidang kata sandi benar-benar menghilang dari data respons pada contoh di atas.

1
Perhatikan bahwa Anda dapat menggunakan metode ini hanya untuk bidang yang tidak diperlukan.

Pengecualian model bersarang

Meskipun fastapi hanya memungkinkan melewati satu set nama bidang, jadi hanya dikecualikan, ormar lebih pintar saat menggunakan respons\ _ model\ _ dikecualikan.

Di Ormar, Anda dapat menggunakan dua jenis notasi untuk mengecualikan model bersarang.

Yang pertama adalah kamus dengan bidang bersarang yang mewakili model struktur pohon, dan yang kedua adalah jalur bergaris dua ke nama bidang.

Misalkan kategori pengguna kami adalah model terpisah:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
base _ ormar _ config = ormar. 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 = 255)
    Prioritas: int = ormar. Integer (nullable = Benar)


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: Opsional [Kategori] = ormar. ForeignKey (Kategori, terkait _ name = "kategori")

Jika Anda ingin mengecualikan prioritas dari kategori dalam tanggapan, Anda masih dapat menggunakan parameter fastAPI.

1
2
3
@app.post ("/ pengguna /," respon _ model = Pengguna, respon _ model _ tidak termasuk ={"category__priority"})
Async def create _ user (pengguna: Pengguna):
    Kembali menunggu user.save

Perhatikan bahwa Anda dapat menggunakan garis bawah ganda untuk masuk lebih dalam ke model, dan jika Anda ingin mengecualikan beberapa bidang dari model bersarang, Anda harus mendahuluinya dengan jalur penuh. Dalam contoh response_model_exclude={"category__priority", "category__other_field", category__nested_model__nested_model_field} ETC.

!!!Catatan Untuk membaca lebih lanjut tentang kemungkinan pengecualian dan cara membuat kamus atau pengaturan pengecualian, kunjungi bagian Fields dari dokumentasi

Perhatikan bahwa selain respon\ _ model\ _ tidak termasuk parameter, fastapi juga mendukung parameter lain yang diwarisi dari pydantic. Semua ini juga bekerja dengan ormar, tetapi mungkin ada beberapa nuansa, jadi sebaiknya baca bagian dict dari dokumentasi.

Tidak termasuk dalam Model.model\ _ dump ()

Atau, Anda bisa mengembalikan kamus dari ormar. Model dan gunakan.

Seperti ini, Anda juga dapat mengatur Exclude / Include sebagai kamus dan mengecualikan bidang pada model bersarang.

!!!Peringatan Tidak menggunakan model\ _ respons akan menyebabkan dokumentasi API tidak memiliki contoh dan skema respons, karena secara teori respons dapat memiliki format apa pun.

1
2
3
4
5
@app.post ("/ users2 /," respon _ model = Pengguna)
Async def membuat _ user2 (pengguna: Pengguna):
    Pengguna = menunggu user.save
    Model pengguna kembali _ dump (tidak termasuk ={'password'})
    # bisa juga sesuatu seperti pengguna kembali. model _ dump (tidak termasuk = {'kategori':{'priority'}}) untuk mengecualikan prioritas kategori

!!!Perhatikan bahwa meskipun Anda melewati bidang kata sandi dalam permintaan, contoh di atas akan membatalkan bidang kata sandi, tetapi bidang tersebut akan tetap ada karena merupakan bagian dari skema respons dan nilainya akan disetel ke Tidak Ada.

Jika Anda ingin mengecualikan bidang sepenuhnya dengan cara ini, jangan gunakan respons\ _ model dan mengecualikannya dalam model\ _ dump ()

Atau, Anda bisa mengembalikan kamus dari model ormar. Seperti ini, Anda juga dapat mengatur Exclude / Sertakan ke kamus dan mengecualikan bidang pada model bersarang.

!!!Perhatikan bahwa secara teori, Anda kehilangan validasi respons di sini, tetapi karena Anda beroperasi di ormar. Model, data respons sudah divalidasi setelah kueri basis data (karena model ormar adalah model pydantic).

Jadi jika Anda melewatkan respons\ _ model sepenuhnya, Anda dapat melakukan hal berikut:

1
2
3
4
@app.post ("/ users4 /")
Sinkronisasi def buat _ user4 (pengguna: Pengguna):
    Pengguna = menunggu user.save
    Model pengguna kembali _ dump (tidak termasuk ={'last_name'})

!!!Perhatikan bahwa ketika Anda melewatkan respons\ _ model, sekarang Anda juga dapat mengecualikan bidang yang diperlukan karena respons tidak lagi divalidasi setelah kembali.

1
Biaya solusi ini adalah Anda kehilangan dokumentasi api sebagai skema respons yang tidak diketahui dari perspektif fastapi.

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
# hasilkan pohon model tanpa kata sandi pada Pengguna dan tanpa prioritas pada Kategori bersarang
ResponseUser = User. get _ pydantic (kecualikan = {"password":..., "kategori":{"priority"}})
@app.post ("/ users3 /," respon _ model = ResponseUser) # gunakan model yang dihasilkan di sini
Sinkronisasi def buat _ user3 (pengguna: Pengguna):
    Kembali menunggu user.save

!!! 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.

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
Impor pydantic

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

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


@app.post ("/ users3 /," respon _ model = UserBase) # gunakan model pydantic di sini
Async def create _ user3 (pengguna: Pengguna): # gunakan model ormar di sini (tapi tentu saja Anda BISA menggunakan pydantic juga di sini)
    Kembali menunggu user.save