Pydantic Data Validation

Generate Python code for data validation and parsing using Pydantic v2 type hints. Pydantic provides fast, extensible data validation using pure Python type annotations.

What This Skill Does

This skill helps you create type-safe data models with automatic validation, parsing, and serialization using Pydantic. It generates BaseModel classes, custom validators, field configurations, and JSON schemas following Pydantic v2 best practices.

Instructions

When the user requests Pydantic-related code generation or validation logic:

1. **Understand Requirements**

- Identify the data structure to validate (API request/response, config, database model, etc.)

- Determine validation rules (required fields, constraints, custom validators)

- Check if serialization or JSON schema generation is needed

- Note any performance requirements or specific Pydantic features requested

2. **Generate BaseModel Class**

- Create a class inheriting from `pydantic.BaseModel`

- Use Python 3.9+ type hints for field definitions

- Add default values where appropriate

- Include optional fields using `Optional` or `Field(default=None)`

- Use `Field()` for advanced configuration (validation, aliases, descriptions)

3. **Add Validation Logic**

- Use field validators with `@field_validator` decorator for field-level validation

- Use model validators with `@model_validator` for cross-field validation

- Implement custom validation functions with clear error messages

- Add constraints using `Annotated` types or Field parameters (min/max, regex, etc.)

4. **Configure Serialization**

- Add `model_config` for model-wide settings (strict mode, extra fields, etc.)

- Use `@field_serializer` for custom serialization logic

- Implement `model_dump()` and `model_dump_json()` examples when needed

- Add computed fields with `@computed_field` decorator if derived values are needed

5. **Add Type-Specific Features**

- Use Pydantic types for common patterns (`EmailStr`, `HttpUrl`, `UUID`, `datetime`, etc.)

- Add `constr`, `conint`, `confloat` for constrained types

- Use `discriminator` for tagged unions

- Implement `RootModel` for validating lists or primitive types directly

6. **Generate JSON Schema (if requested)**

- Use `model_json_schema()` to generate JSON Schema

- Configure schema generation with `json_schema_extra` or `field_schema`

- Add examples and descriptions for API documentation

7. **Add Usage Examples**

- Show basic instantiation and validation

- Demonstrate validation errors with invalid data

- Include parsing from JSON, dicts, or other formats

- Show serialization examples (`model_dump()`, `model_dump_json()`)

8. **Follow Best Practices**

- Use `frozen=True` for immutable models when appropriate

- Set `strict=True` for stricter type coercion when needed

- Use `validate_default=True` to validate default values

- Avoid `Extra.forbid` unless explicitly required

- Prefer `Annotated` types over `Field()` for simple constraints

- Use descriptive error messages in validators

Example Usage Patterns

**Basic Model:**

```python

from pydantic import BaseModel, Field

from datetime import datetime

class User(BaseModel):

id: int

name: str = Field(min_length=1, max_length=100)

email: str

created_at: datetime = Field(default_factory=datetime.now)

friends: list[int] = []

```

**With Validators:**

```python

from pydantic import BaseModel, field_validator, model_validator

class Product(BaseModel):

name: str

price: float

discount: float = 0.0

@field_validator('price')

@classmethod

def price_must_be_positive(cls, v):

if v <= 0:

raise ValueError('Price must be positive')

return v

@model_validator(mode='after')

def check_discount(self):

if self.discount > self.price:

raise ValueError('Discount cannot exceed price')

return self

```

**Custom Types and Serialization:**

```python

from pydantic import BaseModel, EmailStr, HttpUrl, field_serializer

from typing import Annotated

class Company(BaseModel):

name: str

website: HttpUrl

contact_email: EmailStr

revenue: Annotated[float, Field(ge=0)]

@field_serializer('revenue')

def serialize_revenue(self, value):

return f"${value:,.2f}"

```

Important Notes

Constraints