Membina Komponen Teguh dengan FastAPI dan Pydantic

Memanfaatkan Objek yang Ditakrifkan dengan Baik untuk Pengesahan Data yang Cekap

Objek berfungsi sebagai pintu masuk dan keluar untuk komponen, bertindak sebagai pintu masuk asas untuk aliran data. Untuk mencipta komponen yang teguh dan boleh diselenggara, adalah penting untuk menentukan medan yang jelas dan tersusun dengan baik dalam objek ini. Ini memastikan integriti data dan interaksi yang boleh dipercayai antara bahagian sistem yang berbeza. Secara peribadi, saya lebih suka menggunakan Python bersama-sama rangka kerja FastAPI untuk membangunkan API moden yang berprestasi tinggi. Untuk pengesahan data, Pydantic ialah perpustakaan pilihan saya, menyepadukan dengan lancar dengan FastAPI untuk menguatkuasakan kekangan medan secara elegan dan mengekalkan konsistensi di seluruh sistem.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, EmailStr, Field, ValidationError, conint

# FastAPI instance
app = FastAPI()

# Pydantic model for request body validation
class User(BaseModel):
    name: str = Field(..., min_length=3, max_length=50, description="Name must be between 3 and 50 characters")
    age: conint(gt=0, le=120) = Field(..., description="Age must be between 1 and 120")  # Constrained integer type
    email: EmailStr = Field(..., description="Must be a valid email address")

# API route to handle user data submission
@app.post("/create-user/")
async def create_user(user: User):
    try:
        # If validation passes, this will run
        return {"message": f"User {user.name} created successfully!"}
    except ValidationError as e:
        # Catch and return validation errors
        raise HTTPException(status_code=400, detail=e.errors())

# Sample invalid data
invalid_data = {"name": "A", "age": -5, "email": "invalid_email"}

# Simulate calling the route with invalid data
@app.get("/test-invalid-data/")
async def test_invalid_data():
    try:
        user = User(**invalid_data)  # Validation will fail here
    except ValidationError as e:
        return {"error": e.errors()}

# Run the server using: uvicorn <filename>:app --reload

Dalam contoh ini, kami menunjukkan cara FastAPI dan Pydantic bekerjasama untuk mengendalikan pengesahan data dengan cekap. Menggunakan BaseModel Pydantic, kami mentakrifkan peraturan pengesahan untuk data permintaan masuk. Sebagai contoh, kami menggunakan EmailStr untuk mengesahkan format e-mel secara automatik, memudahkan proses tanpa memerlukan regex tersuai. Begitu juga, kami menggunakan conint (jenis integer terhad) untuk memastikan umur berada dalam julat tertentu, dari 1 hingga 120. Pendekatan ini meningkatkan kebolehbacaan dan keselamatan.

Dalam kod contoh, model Pengguna ditakrifkan dengan medan seperti nama, umur dan e-mel, masing-masing mempunyai kriteria pengesahannya. Apabila pengguna menyerahkan data melalui laluan /create-user/, FastAPI secara automatik mengesahkan input terhadap peraturan ini. Jika sah, pengguna berjaya dibuat; jika tidak, FastAPI menimbulkan 400 Permintaan Buruk dengan mesej ralat terperinci. Ini dengan ketara mengurangkan risiko memproses data yang salah atau berniat jahat, menjadikan FastAPI pilihan yang berkuasa untuk pembangunan API yang selamat.

Pengesahan Medan/Model Tersuai dengan Pydantic

Pydantic v2 memperkenalkan pengesahan peringkat model, membolehkan anda mengesahkan berbilang medan berhubung antara satu sama lain menggunakan penghias @model_validator. Pengesahan ini dijalankan selepas pengesahan medan dan amat berguna untuk memastikan syarat tertentu antara medan dipenuhi. Sebagai contoh, anda mungkin ingin mengesahkan bahawa tarikh_mula berlaku sebelum tarikh_akhir dalam model acara:

from pydantic import BaseModel, model_validator
from datetime import date

class Event(BaseModel):
    name: str
    start_date: date
    end_date: date

    @model_validator(mode='after')
    def check_dates(cls, values):
        start, end = values.get('start_date'), values.get('end_date')
        if start and end and start >= end:
            raise ValueError('start_date must be before end_date')
        return values

Dalam contoh ini, @model_validator menyemak bahawa tarikh_mula lebih awal daripada tarikh_akhir. Jika syarat ini tidak dipenuhi, Pydantic menimbulkan ralat pengesahan. Pengesahan peringkat model ini bermanfaat untuk memastikan perhubungan antara berbilang medan dikuatkuasakan dengan tepat.

Serialisasi Tersuai dalam Pydantic

Pydantic membenarkan penyiaran tersuai medan model dengan mengatasi kaedah dict() atau json(). Ini berguna apabila anda ingin mengubah suai format output atau mengecualikan medan tertentu semasa bersiri. Anda juga boleh menggunakan penghias @property untuk menambah medan pengiraan yang disertakan dalam penyirian tetapi bukan sebahagian daripada data mentah model.

Berikut ialah contoh siri tersuai yang mengubah suai cara nama penuh dikembalikan sambil mengecualikan medan kata laluan daripada output bersiri:

from pydantic import BaseModel

class User(BaseModel):
    first_name: str
    last_name: str
    password: str

    # Custom serialization to return the full name
    @property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    # Overriding dict() to exclude the password
    def dict(self, **kwargs):
        result = super().dict(**kwargs)
        result['full_name'] = self.full_name  # Add computed field
        result.pop('password', None)  # Remove password from serialization
        return result

# Example usage
user = User(first_name="John", last_name="Doe", password="secret123")
print(user.dict())

Dalam contoh ini, full_name ialah harta yang dikira dan kami mengatasi kaedah dict() untuk memastikan kata laluan dikecualikan daripada output. Siri tersuai seperti ini menawarkan kawalan terperinci tentang cara data model didedahkan dalam API atau respons.

FastAPI dan Integrasi Pydantic

Pydantic menyepadukan dengan lancar dengan FastAPI, menyediakan pengesahan data automatik untuk muatan permintaan, parameter pertanyaan dan parameter laluan. Apabila anda mentakrifkan model Pydantic dalam titik akhir FastAPI, FastAPI secara automatik mengendalikan penghuraian dan mengesahkan data masuk terhadap peraturan model. Jika data tidak sah, FastAPI mengembalikan respons 422 Entiti Tidak Boleh Diproses terperinci dengan mesej ralat yang jelas.

Ini contoh mudah:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    username: str
    age: int

@app.post("/users/")
async def create_user(user: User):
    return {"message": f"User {user.username} created successfully!"}

Dalam contoh ini, apabila permintaan POST dihantar kepada /users/, FastAPI menggunakan Pydantic untuk mengesahkan data JSON yang masuk. Jika data tidak mematuhi model Pengguna (mis., nama pengguna hilang atau umur tidak sah), FastAPI secara automatik mengembalikan respons ralat, memudahkan pengesahan input dan pengendalian ralat.

Ringkasan

Ringkasnya, memanfaatkan Pydantic dengan FastAPI meningkatkan keupayaan anda untuk mencipta aplikasi yang teguh dan boleh diselenggara dengan memastikan integriti data melalui pengesahan yang jelas. Gabungan hebat ini memudahkan proses pembangunan sambil meningkatkan keselamatan dan kebolehpercayaan, menjadikannya pilihan pilihan untuk membina API moden.

Rujukan

Ciri pydantic dalam FastAPI
Pelan Pydantic V2

---

Atas ialah kandungan terperinci Membina Komponen Teguh dengan FastAPI dan Pydantic. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!