Pydantic Alan Doğrulaması ve Doğrulayıcılar

Why Validate with Pydantic?

Using Pydantic's `Field` Function

from pydantic import BaseModel, Field

class User(BaseModel):
    username: str = Field(min_length=3, max_length=15)
    age: int

# Valid
try:
    user1 = User(username="coddy", age=25)
    print(f"Valid username: {user1.username}")
except Exception as e:
    print(e)

# Invalid username (too short)
try:
    user2 = User(username="c", age=30)
except Exception as e:
    print(f"Error: {e}")

Numeric Field Rules

from pydantic import BaseModel, Field

class Product(BaseModel):
    name: str
    price: float = Field(gt=0, le=1000) # Price > 0 and <= 1000
    stock: int = Field(ge=0) # Stock >= 0

# Valid
try:
    product1 = Product(name="Book", price=19.99, stock=100)
    print(f"{product1.name} price: {product1.price}")
except Exception as e:
    print(e)

# Invalid price (negative)
try:
    product2 = Product(name="Pen", price=-5.0, stock=50)
except Exception as e:
    print(f"Error: {e}")

Regex for Field Validation

from pydantic import BaseModel, Field

class ItemCode(BaseModel):
    # Code must be three uppercase letters, a hyphen, then four digits
    code: str = Field(pattern=r"^[A-Z]{3}-\d{4}$") # e.g., ABC-1234

# Valid
try:
    item1 = ItemCode(code="XYZ-9876")
    print(f"Valid code: {item1.code}")
except Exception as e:
    print(f"Error: {e}")

# Invalid format (lowercase letters)
try:
    item2 = ItemCode(code="abc-1234")
except Exception as e:
    print(f"Error: {e}")

Crafting Custom Validators

Custom Logic for Fields

from pydantic import BaseModel, validator
import re

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

    @validator('password')
    def password_has_digit(cls, v):
        if not re.search(r"\d", v):
            raise ValueError('password must contain at least one digit')
        return v

# Valid
try:
    user1 = UserAuth(username="coder", password="MySecureP@ss1")
    print(f"Password OK for {user1.username}")
except Exception as e:
    print(f"Error: {e}")

# Invalid password (no digits)
try:
    user2 = UserAuth(username="test", password="NoDigitsHere!")
except Exception as e:
    print(f"Error: {e}")

Data Transformation with `pre=True`

from pydantic import BaseModel, validator

class SearchQuery(BaseModel):
    query: str

    @validator('query', pre=True)
    def strip_whitespace(cls, v):
        if isinstance(v, str):
            return v.strip()
        return v # Pydantic will handle type validation later

# Input with leading/trailing spaces
query1 = SearchQuery(query="   python tutorial   ")
print(f"Cleaned query: '{query1.query}'")

# Input without spaces
query2 = SearchQuery(query="fastapi")
print(f"Cleaned query: '{query2.query}'")

Stacking Field Validators

from pydantic import BaseModel, validator

class TagList(BaseModel):
    tags: list[str]

    @validator('tags', each_item=True)
    def tag_must_be_lowercase(cls, v):
        if v != v.lower():
            raise ValueError('tag must be lowercase')
        return v

    @validator('tags', each_item=True)
    def tag_min_length(cls, v):
        if len(v) < 2:
            raise ValueError('tag must be at least 2 chars')
        return v

# Valid
try:
    tags1 = TagList(tags=["python", "fastapi"])
    print(f"Tags OK: {tags1.tags}")
except Exception as e:
    print(f"Error: {e}")

# Invalid (uppercase and too short)
try:
    tags2 = TagList(tags=["PY", "a"])
except Exception as e:
    print(f"Error: {e}")

Cross-Field Validation with Root Validators

Root Validator in Action

from pydantic import BaseModel, root_validator, ValidationError

class Registration(BaseModel):
    email: str
    password: str
    password_confirm: str

    @root_validator()
    def passwords_match(cls, values):
        pw1, pw2 = values.get('password'), values.get('password_confirm')
        if pw1 is not None and pw2 is not None and pw1 != pw2:
            raise ValueError('passwords do not match')
        return values

# Valid
try:
    reg1 = Registration(email="a@b.com", password="P@ssword1", password_confirm="P@ssword1")
    print("Registration valid!")
except ValidationError as e:
    print(f"Error: {e}")

# Invalid (passwords don't match)
try:
    reg2 = Registration(email="x@y.com", password="P@ssword1", password_confirm="P@ssword2")
except ValidationError as e:
    print(f"Error: {e}")

Validation Checkpoint

from pydantic import BaseModel, Field, validator
import re

class UserProfile(BaseModel):
    username: str = Field(min_length=5, max_length=20)
    email: str
    age: int = Field(gt=18)
    bio: str = ""

    @validator('email')
    def validate_email_format(cls, v):
        if not re.match(r"[^@]+@[^@]+\.[^@]+", v):
            raise ValueError('Invalid email format')
        return v

Recap: Mastering Validation