Hur skriver du anpassad validering i Pydantic?

Question

Accepted Answer

Utöver inbyggda begränsningar låter Pydantic dig skriva **anpassad valideringslogik** med fältvalidatorer (validera ett fält) och modellvalidatorer (validera över flera fält) — för regler som enkla begränsningar inte kan uttrycka. (Syntaxen som visas är för Pydantic v2.)

## Fältvalidatorer — validera/transformera ett enskilt fält

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

En `@field_validator` kör anpassad logik på ett fält: höj `ValueError` för att förkasta ogiltiga inmatningar (FastAPI förvandlar det till ett tydligt 422), eller returnera ett transformerat värde (t.ex. normalisering till gemener).

## Modellvalidatorer — validering över flera fält

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

En `@model_validator(mode="after")` körs efter att alla fält validerats, med åtkomst till hela modellen — används för regler som involverar **flera fält** (t.ex. bekräftelse att lösenord matchar, eller att ett startdatum går före ett slutdatum).

## Inbyggd validering räcker ofta först

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

Föredra `Field`-begränsningar och specialiserade typer för enkla regler; använd anpassade validatorer för genuin affärslogik.

## Varför det är viktigt

Anpassad Pydantic-validering är viktigt för att tillämpa affärsregler som går bortom enkla typkontroller och begränsningar — och eftersom validering är kritisk för **säkerhet och dataintegritet**, är möjligheten att uttrycka vilken regel som helst värdefull. **Fältvalidatorer** hanterar logik på en enskild fältnivå (anpassade formatkontroller, normalisering/transformering), medan **modellvalidatorer** hanterar det vanliga behovet av **validering över flera fält** (lösenord som matchar, datumintervall, villkorliga krav) som regler på fältnivå inte kan uttrycka.

Validatorerna integreras sömlöst med FastAPI — en upphöjd `ValueError` blir automatiskt ett tydligt 422-svar.

Att förstå när man ska använda inbyggda begränsningar/typer (för enkla regler) kontra anpassade validatorer (för verklig affärslogik), och hur fält- kontra modellvalidatorer skiljer sig åt, låter dig säkerställa att inkommande data fullt ut uppfyller dina applikationskrav, vilket gör denna kunskap viktigt för att bygga robusta, korrekta API:er.