Pydantic-இல் custom validation-ஐ எவ்வாறு எழுதுவது?

Question

Accepted Answer

உள்ளமைந்த constraints-ஐத் தாண்டி, Pydantic உங்களை field validators (ஒரு field-ஐ validate செய்கிறது) மற்றும் model validators (பல fields முழுவதும் validate செய்கிறது) ஆகியவற்றுடன் **custom validation logic** எழுத அனுமதிக்கிறது — எளிய constraints வெளிப்படுத்த முடியாத விதிகளுக்கு. (காட்டப்படும் syntax Pydantic v2.)

## Field validators — ஒரு 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
```

ஒரு `@field_validator` ஒரு field-இல் custom logic-ஐ இயக்குகிறது: தவறான input-ஐ நிராகரிக்க `ValueError`-ஐ எழுப்பவும் (FastAPI இதை தெளிவான 422-ஆக மாற்றுகிறது), அல்லது transform செய்யப்பட்ட மதிப்பை return செய்யவும் (எ.கா. lowercase-ஆக சீரமைத்தல்).

## 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
```

ஒரு `@model_validator(mode="after")` எல்லா fields-ம் validate செய்யப்பட்ட பிறகு, முழு model-க்கான அணுகலுடன் இயங்குகிறது — **பல fields** சம்பந்தப்பட்ட விதிகளுக்குப் பயன்படுத்தப்படுகிறது (எ.கா. passwords match ஆகின்றனவா என உறுதிப்படுத்துதல், அல்லது start date ஒரு end date-க்கு முன் இருக்கிறதா).

## உள்ளமைந்த 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
```

எளிய விதிகளுக்கு `Field` constraints மற்றும் சிறப்பு types-ஐ விரும்புங்கள்; உண்மையான business logic-க்கு custom validators-ஐப் பயன்படுத்துங்கள்.

## இது ஏன் முக்கியம்

Custom Pydantic validation எளிய type checks மற்றும் constraints-ஐத் தாண்டிய business rules-ஐ அமல்படுத்துவதற்கு முக்கியமானது — மேலும் validation **security மற்றும் data integrity**-க்கு முக்கியமானதால், எந்த விதியையும் வெளிப்படுத்தும் திறன் மதிப்புமிக்கது. **Field validators** single-field logic-ஐ (custom format checks, normalization/transformation) கையாளுகின்றன, அதே சமயம் **model validators** field-level விதிகளால் வெளிப்படுத்த முடியாத **cross-field validation** (passwords match ஆதல், date ranges, conditional requirements) என்ற பொதுவான தேவையைக் கையாளுகின்றன.

validators FastAPI-உடன் சீராக integrate ஆகின்றன — எழுப்பப்பட்ட `ValueError` தானாகவே ஒரு தெளிவான 422 response-ஆக மாறுகிறது.

உள்ளமைந்த constraints/types-ஐ (எளிய விதிகளுக்கு) எப்போது பயன்படுத்துவது மற்றும் custom validators-ஐ (உண்மையான business logic-க்கு) எப்போது பயன்படுத்துவது, மேலும் field vs model validators எவ்வாறு வேறுபடுகின்றன என்பதைப் புரிந்துகொள்வது, வரும் தரவு உங்கள் application-இன் தேவைகளை முழுமையாக பூர்த்தி செய்வதை உறுதிப்படுத்த உங்களை அனுமதிக்கிறது, இது robust, correct APIs-ஐ உருவாக்குவதற்கான முக்கியமான அறிவாக மாற்றுகிறது.