Pydantic లో custom validation ను ఎలా వ్రాయాలి?

Question

Accepted Answer

Built-in constraints కు అతిరిక్తంగా, Pydantic మీకు **custom validation logic** ను field validators (ఒక field ను validate చేయడానికి) మరియు model validators (బహుళ fields లలో validate చేయడానికి) తో వ్రాయడానికి అనుమతిస్తుంది — సాధారణ constraints తో express చేయలేని rules కోసం. (చూపిన Syntax Pydantic v2.)

## Field validators — single field ను validate/transform చేయడం

```python
from pydantic import BaseModel, field_validator

class User(BaseModel):
    username: str
    password: str

@field_validator("username")
    @classmethod
    def username_alphanumeric(cls, v: str) -> str:
        if not v.isalnum():
            raise ValueError("username must be alphanumeric")   # → a 422 error
        return v.lower()                                         # can also TRANSFORM the value
```

A `@field_validator` ఒక field పై custom logic ను నడుపుతుంది: invalid input ను reject చేయడానికి `ValueError` ను raise చేయండి (FastAPI దీనిని clear 422 గా మార్చుతుంది), లేదా transformed value ను return చేయండి (ఉ.దా. lowercase కు normalizing).

## Model validators — cross-field validation

```python
from pydantic import model_validator

class SignupForm(BaseModel):
    password: str
    confirm_password: str

@model_validator(mode="after")
    def passwords_match(self):
        if self.password != self.confirm_password:    # compare MULTIPLE fields
            raise ValueError("passwords do not match")
        return self
```

A `@model_validator(mode="after")` అన్ని fields validate చేయబడిన తర్వాత నడుపుతుంది, మొత్తం model కు access ఉండటి తో — **multiple fields** (ఉ.దా. passwords matching ను confirming చేయడం, లేదా start date end date కు ముందు ఉందో) సంబంధించిన rules కోసం ఉపయోగించబడుతుంది.

## Built-in validation తరచుగా మొదటిసారి సరిపోతుంది

```python
class Product(BaseModel):
    price: float = Field(gt=0)          # use Field constraints for simple rules
    sku: str = Field(pattern=r"^[A-Z]{3}-\d+$")
    email: EmailStr                      # specialized types for formats
# reach for custom validators only when constraints/types can't express the rule
```

సాధారణ rules కోసం `Field` constraints మరియు specialized types కు preference ఇవ్వండి; genuine business logic కోసం custom validators ను ఉపయోగించండి.

## ఇది ఎందుకు ముఖ్యమైనది

Custom Pydantic validation సాధారణ type checks మరియు constraints కు అతిరిక్తంగా business rules ను enforce చేయడానికి ముఖ్యమైనది — మరియు validation **security మరియు data integrity** కోసం క్రిటికల్ గా ఉంది కనుక, ఏదైనా rule ను express చేయగలిగిన సామర్థ్యం విలువైనది. **Field validators** single-field logic (custom format checks, normalization/transformation) ను సంభాలుతాయి, అయితే **model validators** **cross-field validation** (passwords matching, date ranges, conditional requirements) యొక్క సాధారణ అవసరాన్ని సంభాలుతాయి field-level rules which express చేయలేవు.

Validators FastAPI తో seamlessly integrate చేస్తాయి — raised `ValueError` automatically clear 422 response గా మారుతుంది.

Built-in constraints/types (simple rules కోసం) వర్సెస్ custom validators (real business logic కోసం) ఎప్పుడు ఉపయోగించాలో, మరియు field vs model validators ఎలా భిన్నంగా ఉన్నాయో అర్థం చేసుకోవడం, incoming data మీ application యొక్క requirements ను పూర్తిగా సంతృప్తి చేస్తుందో నిశ్చితం చేస్తుంది, robust, correct APIs ను నిర్మించడానికి ఇది ముఖ్యమైన జ్ఞానం చేస్తుంది.