type checking-ஐத் தாண்டி, FastAPI உங்களை Query, Path, மற்றும் Field ஆகியவற்றைப் பயன்படுத்தி path/query parameters மற்றும் model fields-க்கு constraints சேர்க்க அனுமதிக்கிறது — length, ranges, மற்றும் patterns போன்ற விதிகளை அமல்படுத்துகிறது, மீறப்படும்போது தானியங்கி 422 errors மற்றும் documentation-உடன்.
from fastapi import Query, Path
@app.get("/items")
def search(
q: str = Query(min_length=3, max_length=50), # string length bounds
page: int = Query(default=1, ge=1), # >= 1
limit: int = Query(default=10, ge=1, le=100), # 1 <= limit <= 100
code: str = Query(pattern=r"^[A-Z]{3}$"), # regex pattern
):
...
@app.get("/items/{item_id}")
def get(item_id: int = Path(ge=1)): # path param must be >= 1
...
Query() மற்றும் Path() ஆகியவை query மற்றும் path parameters-க்கு constraints சேர்க்கின்றன. பொதுவானவை: min_length/max_length (strings), ge/gt/le/lt (numbers), pattern (regex). மீறல்கள் தானாகவே தெளிவான 422 error-ஐ உருவாக்குகின்றன.
from pydantic import BaseModel, Field, EmailStr
class User(BaseModel):
name: str = Field(min_length=1, max_length=100)
age: int = Field(ge=0, le=120)
email: EmailStr # format validation via a type
bio: str = Field(default="", max_length=500, description="User bio")
அதே constraints Field() மூலம் model fields-க்கும் பொருந்தும், request bodies-ஐ validate செய்கின்றன. சிறப்பு types (EmailStr, HttpUrl, UUID) formats-ஐ validate செய்கின்றன.
q: str = Query(min_length=3, description="Search query", example="phone")
# the constraints + description + example appear in the auto-generated API docs
நீங்கள் அறிவிக்கும் ஒவ்வொரு constraint-ம் OpenAPI documentation-இலும் பிரதிபலிக்கப்படுகிறது, எனவே consumers விதிகளைப் பார்க்கிறார்கள்.
validation constraints சேர்ப்பது security/robustness மற்றும் நல்ல API design ஆகிய இரண்டிற்கும் முக்கியமானது — விதிகளை (length limits, numeric ranges, regex patterns, format types) அறிவிப்பது, தவறான அல்லது தீங்கிழைக்கும் input உங்கள் logic-ஐ அடைவதற்கு முன்பே தெளிவான errors-உடன் நிராகரிக்கப்படுவதை உறுதி செய்கிறது, இது raw input-ஐ ஒருபோதும் நம்பக்கூடாது என்பதால் அவசியமானது.
FastAPI இதை declarative-ஆகவும் முயற்சியின்றியும் ஆக்குகிறது: Query/Path/Field constraints தானாகவே validate செய்யப்படுகின்றன (structured 422 errors-ஐ உருவாக்குகின்றன) மற்றும் ஒரே நேரத்தில் API docs-இல் documented செய்யப்படுகின்றன, எனவே விதிகள் ஒரே அறிவிப்பிலிருந்து அமல்படுத்தப்பட்டு தெரிவிக்கப்படுகின்றன.
பொதுவான constraints மற்றும் சிறப்பு validation types-ஐ அறிந்திருப்பது பாதுகாப்பான, நன்கு வரையறுக்கப்பட்ட endpoints-ஐ உருவாக்குவதற்கான தினசரி அறிவாகும் — அடிப்படை type checking-ஐத் தாண்டி உங்கள் தரவு பூர்த்தி செய்ய வேண்டிய உண்மையான business rules-ஐ அமல்படுத்துவது இவ்வாறுதான்.