Pythonic Data Validation: Beyond Basic Checks with Pydantic in 2024

Data validation is crucial for building robust and reliable Python applications. In 2024, Pydantic has become a go-to library for not just basic type checking, but also for sophisticated data validation and serialization. This blog post will explore how to leverage Pydantic to go beyond simple checks and implement truly Pythonic data validation.

Why Pydantic?

Pydantic excels at:

• Data Validation: Enforces data types and constraints, preventing unexpected errors.
• Data Serialization/Deserialization: Seamlessly converts Python objects to and from JSON, YAML, and other formats.
• Automatic Documentation: Generates JSON Schema for your data models, facilitating API documentation.
• Type Hints Integration: Works flawlessly with Python’s type hinting system, improving code readability and maintainability.
• Developer Experience: Provides a clear and intuitive API, making data validation a breeze.

Basic Validation with Pydantic

Let’s start with a basic example. We’ll define a User model with name, age, and email attributes.

from pydantic import BaseModel, EmailStr, validator

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

user_data = {
    "name": "Alice",
    "age": 30,
    "email": "alice@example.com"
}

user = User(**user_data)
print(user)

In this example:

• BaseModel is the foundation for Pydantic models.
• Type hints (e.g., str, int, EmailStr) define the expected data types.
• EmailStr is a built-in Pydantic type that validates email addresses.

If user_data contains invalid values, Pydantic will raise a ValidationError.

Going Beyond Basic Checks

Now, let’s explore more advanced validation techniques.

Custom Validation with @validator

The @validator decorator allows you to define custom validation logic for your fields. Let’s add a validation to ensure the user’s age is within a reasonable range.

from pydantic import BaseModel, EmailStr, validator, ValidationError

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

    @validator('age')
    def validate_age(cls, age):
        if age < 0 or age > 120:
            raise ValueError('Age must be between 0 and 120')
        return age

try:
    user_data = {
        "name": "Bob",
        "age": 150,
        "email": "bob@example.com"
    }

    user = User(**user_data)
    print(user)
except ValidationError as e:
    print(e)

In this example:

• We define a validate_age method decorated with @validator('age'). This indicates that this method should validate the age field.
• If the age is outside the acceptable range, we raise a ValueError.
• The ValueError is automatically converted into a Pydantic ValidationError.

Field-Level Validation with Field

The Field function provides more control over individual fields, allowing you to specify constraints like minimum and maximum values, regular expressions, and more.

from pydantic import BaseModel, EmailStr, Field

class Product(BaseModel):
    name: str = Field(..., min_length=3, max_length=50) # Required field
    price: float = Field(..., gt=0) # Required field, greater than 0
    description: str = Field(None, max_length=200) # Optional field

product_data = {
    "name": "Awesome Gadget",
    "price": 99.99,
    "description": "A must-have gadget!"
}

product = Product(**product_data)
print(product)

Here, Field(...) makes name and price required fields. min_length, max_length, and gt impose further restrictions.

Root Validation with @root_validator

Sometimes you need to validate multiple fields in relation to each other. @root_validator allows you to validate the entire model after all individual field validations have passed.

from pydantic import BaseModel, validator, root_validator

class DateRange(BaseModel):
    start_date: str
    end_date: str

    @root_validator(pre=False)
    def validate_date_range(cls, values):
        start_date, end_date = values.get('start_date'), values.get('end_date')
        if start_date and end_date:
            if start_date > end_date:
                raise ValueError('start_date must be before end_date')
        return values

date_range_data = {
    'start_date': '2024-10-27',
    'end_date': '2024-10-26'
}

try:
    date_range = DateRange(**date_range_data)
    print(date_range)
except ValueError as e:
    print(e)

Data Transformation with pre=True

You can use pre=True in @validator and @root_validator to transform data before validation. This is useful for cleaning or normalizing data.

from pydantic import BaseModel, validator

class Item(BaseModel):
    name: str

    @validator('name', pre=True)
    def lower_case_name(cls, name):
        if isinstance(name, str):
            return name.lower()
        return name  # Handle non-string inputs gracefully

item_data = {
    "name": "AwesomeItem"
}

item = Item(**item_data)
print(item)

Conclusion

Pydantic provides a powerful and Pythonic way to perform data validation. By using custom validators, field constraints, and root validators, you can ensure the integrity of your data and build more robust applications. The library’s seamless integration with type hints and automatic documentation generation further enhances the developer experience. Embrace Pydantic in 2024 to elevate your data validation game!