Pydantic v2: Rust-Powered Data Validation for Python

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str
    age: int

# Valid data
user = User(id=1, name='Alice', email='alice@example.com', age=30)
print(user)
# Output: id=1 name='Alice' email='alice@example.com' age=30

# Invalid data raises ValidationError
try:
    User(id='not_int', name='Bob', email='bob@test', age=150)
except Exception as e:
    print(e)

from pydantic import BaseModel, Field, conint, constr
from typing import Optional
from datetime import datetime

class Product(BaseModel):
    id: int
    name: constr(min_length=1, max_length=100)
    price: confloat(ge=0.0)  # greater than or equal to 0
    quantity: conint(ge=0, le=1000)
    created_at: datetime = Field(default_factory=datetime.now)
    description: Optional[str] = None

# Valid
product = Product(id=1, name='Widget', price=9.99, quantity=10)
print(product.model_dump())
# Output: {'id': 1, 'name': 'Widget', 'price': 9.99, 'quantity': 10, 'created_at': datetime.datetime(...), 'description': None}

# Invalid price
try:
    Product(id=2, name='Gadget', price=-5.0, quantity=5)
except Exception as e:
    print(e)

from pydantic import BaseModel, field_validator, model_validator
from typing import Any

class Order(BaseModel):
    items: list[str]
    total: float

    @field_validator('total')
    @classmethod
    def check_total_positive(cls, v: float) -> float:
        if v <= 0:
            raise ValueError('Total must be positive')
        return v

    @model_validator(mode='after')
    def check_items_not_empty(self) -> 'Order':
        if not self.items:
            raise ValueError('Order must have at least one item')
        return self

# Valid
order = Order(items=['apple', 'banana'], total=5.99)
print(order.model_dump())

# Invalid
try:
    Order(items=[], total=0)
except Exception as e:
    print(e)

from pydantic import BaseModel
import json

class User(BaseModel):
    id: int
    name: str
    email: str

user = User(id=1, name='Alice', email='alice@example.com')

# Serialize to dict
print(user.model_dump())
# Output: {'id': 1, 'name': 'Alice', 'email': 'alice@example.com'}

# Serialize to JSON
print(user.model_dump_json())
# Output: {"id": 1, "name": "Alice", "email": "alice@example.com"}

# Deserialize from dict
data = {'id': 2, 'name': 'Bob', 'email': 'bob@example.com'}
user2 = User.model_validate(data)
print(user2)

# Deserialize from JSON string
json_str = '{"id": 3, "name": "Charlie", "email": "charlie@example.com"}'
user3 = User.model_validate_json(json_str)
print(user3)

from pydantic import BaseModel, Field

class LooseModel(BaseModel):
    age: int

class StrictModel(BaseModel):
    model_config = {'strict': True}
    age: int

# Loose: coerces string to int
print(LooseModel(age='30').model_dump())
# Output: {'age': 30}

# Strict: raises error
try:
    StrictModel(age='30')
except Exception as e:
    print(e)

# Per-field strict
class MixedModel(BaseModel):
    age: int = Field(strict=True)
    name: str

print(MixedModel(age=25, name='Alice'))  # OK
# MixedModel(age='25', name='Bob') would raise

from pydantic import BaseModel
from typing import List, Optional

class Address(BaseModel):
    street: str
    city: str
    zip_code: str

class User(BaseModel):
    id: int
    name: str
    addresses: List[Address]
    primary_address: Optional[Address] = None

# Valid data
user = User(
    id=1,
    name='Alice',
    addresses=[
        Address(street='123 Main St', city='Springfield', zip_code='12345'),
        Address(street='456 Oak Ave', city='Shelbyville', zip_code='67890')
    ],
    primary_address=Address(street='123 Main St', city='Springfield', zip_code='12345')
)
print(user.model_dump())
# Output: {'id': 1, 'name': 'Alice', 'addresses': [{'street': '123 Main St', 'city': 'Springfield', 'zip_code': '12345'}, {'street': '456 Oak Ave', 'city': 'Shelbyville', 'zip_code': '67890'}], 'primary_address': {'street': '123 Main St', 'city': 'Springfield', 'zip_code': '12345'}}

from pydantic import TypeAdapter
import time

# Validate a list of integers
adapter = TypeAdapter(list[int])
data = list(range(10000))

start = time.perf_counter()
validated = adapter.validate_python(data)
end = time.perf_counter()
print(f'Validated 10k ints in {end-start:.4f} seconds')

# Validate JSON string
json_data = '[' + ','.join(str(i) for i in range(10000)) + ']'
start = time.perf_counter()
validated = adapter.validate_json(json_data)
end = time.perf_counter()
print(f'Validated 10k ints from JSON in {end-start:.4f} seconds')