Pydantic: Robust data models. Zero boilerplate.

Pydantic is a Python library for data validation and settings management using Python type hints. It enforces type hints at runtime and provides user-friendly errors when data is invalid.

Key Features & Benefits

• Data Validation: At its core, Pydantic ensures that data conforms to specified types and constraints. If you define a field as an integer, Pydantic will try to convert incoming data to an integer or raise an error if it can’t. This is incredibly useful for validating data from external sources like API requests or configuration files.
• Type Hinting Power: Pydantic leverages Python’s standard type hints. This means you define your data structures (models) using familiar Python types (e.g., int, str, List, Dict). This makes the code clean, intuitive, and easy to understand.
• Editor Support & Autocompletion: Because Pydantic uses type hints, you get excellent support from modern IDEs and linters. This includes autocompletion, type checking, and refactoring capabilities, which significantly improve developer productivity and code quality.
• Data Serialization & Parsing: Pydantic models can easily serialize data to and parse data from common formats like JSON. For example, you can create a Pydantic model from a JSON string or dictionary and, conversely, export a model instance to a JSON string or dictionary.
• Settings Management: Pydantic provides a convenient way to manage application settings. You can define a settings model that loads values from environment variables, .env files, or even secrets files, with built-in validation.
• Fast: Built on top of pydantic-core (written in Rust), Pydantic is very fast, making it suitable for high-performance applications.
• Integration with Frameworks: Pydantic is widely used and integrates seamlessly with popular Python frameworks, especially web frameworks like FastAPI and Django Ninja, where it’s often used for request and response validation.

Simple Example

Here’s a quick look at how you might define a Pydantic model:

Python

from pydantic import BaseModel, EmailStr, PositiveInt
from typing import List
import datetime

class User(BaseModel):
    id: int
    name: str = 'John Doe' # Default value
    signup_ts: datetime.datetime | None = None # Optional field
    email: EmailStr # Special email validation
    friends: List[int] = []
    age: PositiveInt | None = None # Age must be a positive integer

# Example usage:
external_data = {
    'id': 123,
    'signup_ts': '2022-12-22 12:00',
    'email': 'johndoe@example.com',
    'friends': [1, '2', b'3'], # Pydantic will attempt conversion
    'age': '30'
}

user = User(**external_data)

print(user.id)
# > 123
print(user.email)
# > johndoe@example.com
print(user.friends)
# > [1, 2, 3] (note the type conversion)
print(user.model_dump_json())
# > {"id":123,"name":"John Doe","signup_ts":"2022-12-22T12:00:00","email":"johndoe@example.com","friends":[1,2,3],"age":30}

In this example, Pydantic will automatically validate that id is an integer, email is a valid email format, age is a positive integer (if provided), and it will attempt to convert items in the friends list to integers.

Pydantic’s combination of ease of use, powerful validation capabilities, and integration with type hints has made it a go-to library for many Python developers working with data.