aiskillstore/marketplace / skills/0xdarkmatter/python-fastapi-patterns
python-fastapi-patterns
UnverifiedFastAPI web framework patterns. Triggers on: fastapi, api endpoint, dependency injection, pydantic model, openapi, swagger, starlette, async api, rest api, uvicorn.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 5.2 KB |
| assets/fastapi-template.py | script | 4.9 KB |
| references/background-tasks.md | markdown | 8.4 KB |
| references/dependency-injection.md | markdown | 7.2 KB |
| references/middleware-patterns.md | markdown | 8.8 KB |
| references/validation-serialization.md | markdown | 7.3 KB |
| scripts/scaffold-api.sh | script | 4.1 KB |
| skill-report.json | config | 72.8 KB |
references/validation-serialization.md
View on GitHub# Pydantic v2 Validation & Serialization
Modern validation patterns for FastAPI with Pydantic v2.
## Basic Models
```python
from pydantic import BaseModel, Field, EmailStr
from datetime import datetime
from typing import Annotated
class UserCreate(BaseModel):
"""Request model with field validation."""
name: str = Field(..., min_length=1, max_length=100)
email: EmailStr
age: int = Field(..., ge=0, le=150)
bio: str | None = Field(default=None, max_length=500)
class UserResponse(BaseModel):
"""Response model with ORM support."""
id: int
name: str
email: EmailStr
created_at: datetime
model_config = {"from_attributes": True}
```
## Custom Validators
```python
from pydantic import BaseModel, field_validator, model_validator
from typing import Self
class UserCreate(BaseModel):
username: str
password: str
password_confirm: str
@field_validator("username")
@classmethod
def validate_username(cls, v: str) -> str:
"""Validate single field."""
if not v.isalnum():
raise ValueError("Username must be alphanumeric")
return v.lower()
@model_validator(mode="after")
def validate_passwords(self) -> Self:
"""Validate across multiple fields."""
if self.password != self.password_confirm:
raise ValueError("Passwords don't match")
return self
# Before validation (raw input)
class Config(BaseModel):
port: int
@field_validator("port", mode="before")
@classmethod
def parse_port(cls, v):
"""Convert string to int before validation."""
if isinstance(v, str):
return int(v)
return v
```
## Computed Fields
```python
from pydantic import BaseModel, computed_field
from datetime import datetime
class User(BaseModel):
first_name: str
last_name: str
birth_date: datetime
@computed_field
@property
def full_name(self) -> str:
return f"{self.first_name} {self.last_name}"
@computed_field
@property
def age(self) -> int:
today = datetime.now()
return today.year - self.birth_date.year
```
## Field Serialization
```python
from pydantic import BaseModel, field_serializer
from datetime import datetime
from decimal import Decimal
class Order(BaseModel):
id: int
total: Decimal
created_at: datetime
@field_serializer("total")
def serialize_total(self, value: Decimal) -> str:
"""Serialize Decimal as formatted string."""
return f"${value:.2f}"
@field_serializer("created_at")
def serialize_date(self, value: datetime) -> str:
"""Serialize datetime as ISO string."""
return value.isoformat()
# Or use Annotated with serialization
from pydantic import PlainSerializer
FormattedDecimal = Annotated[
Decimal,
PlainSerializer(lambda v: f"${v:.2f}", return_type=str)
]
class Order(BaseModel):
total: FormattedDecimal
```
## Custom Types
```python
from pydantic import BaseModel, GetCoreSchemaHandler
from pydantic_core import CoreSchema, core_schema
from typing import Any
class PhoneNumber(str):
"""Custom phone number type with validation."""
@classmethod
def __get_pydantic_core_schema__(
cls, source_type: Any, handler: GetCoreSchemaHandler
) -> CoreSchema:
return core_schema.no_info_after_validator_function(
cls._validate,
core_schema.str_schema(),
)
@classmethod
def _validate(cls, v: str) -> "PhoneNumber":
# Remove non-digits
digits = "".join(c for c in v if c.isdigit())
if len(digits) != 10:
raise ValueError("Phone must be 10 digits")
return cls(f"({digits[:3]}) {digits[3:6]}-{digits[6:]}")
class Contact(BaseModel):
name: str
phone: PhoneNumber
# Usage
contact = Contact(name="John", phone="1234567890")
print(contact.phone) # (123) 456-7890
```
## Nested Models
```python
from pydantic import BaseModel
from datetime import datetime
class Address(BaseModel):
street: str
city: str
country: str = "USA"
class Company(BaseModel):
name: str
address: Address
class UserResponse(BaseModel):
id: int
name: str
company: Company | None = None
addresses: list[Address] = []
model_config = {"from_attributes": True}
```
## Discriminated Unions
```python
from pydantic import BaseModel, Field
from typing import Literal, Union
from typing_extensions import Annotated
class Dog(BaseModel):
pet_type: Literal["dog"]
name: str
breed: str
class Cat(BaseModel):
pet_type: Literal["cat"]
name: str
indoor: bool = True
# Use discriminator for efficient parsing
Pet = Annotated[
Union[Dog, Cat],
Field(discriminator="pet_type")
]
class Owner(BaseModel):
name: str
pets: list[Pet]
# FastAPI automatically validates
@app.post("/owners")
async def create_owner(owner: Owner):
return owner
```
## Model Inheritance
```python
from pydantic import BaseModel
from datetime import datetime
class BaseResponse(BaseModel):
"""Base for all responses."""
model_config = {"from_attributes": True}
class TimestampMixin(BaseModel):
"""Mixin for timestamp fields."""
created_at: datetime
updated_at: datetime
class UserBase(BaseModel):
name: str
email: str
class UserCreate(UserBase):
password: str
class UserResponse(UserBase, TimestampMixin, BaseResponse):
id: int
```
## Partial Updates (PATCH)
```python
from pydantic import BaseModel
from typing import Any
class UserUpdate(BaseModel):
"""All fields optional for partial updates."""
name: str | None = None
email: str | None = None
bio: str | None = None
@app.patch("/users/{user_id}")
async def update_user(user_id: int, updates: UserUpdate):
# Only get set fields
update_data = updates.model_dump(exclude_unset=True)
# Apply to existing user
user = await get_user(user_id)
for field, value in update_data.items():
setattr(user, field, value)
return user
```
## Validation Error Handling
```python
from fastapi import Request
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(
request: Request,
exc: RequestValidationError
):
"""Custom validation error response."""
errors = []
for error in exc.errors():
errors.append({
"field": ".".join(str(loc) for loc in error["loc"]),
"message": error["msg"],
"type": error["type"],
})
return JSONResponse(
status_code=422,
content={
"detail": "Validation error",
"errors": errors,
},
)
```
## Quick Reference
| Feature | Pydantic v2 |
|---------|-------------|
| ORM mode | `model_config = {"from_attributes": True}` |
| Field validator | `@field_validator("field")` |
| Model validator | `@model_validator(mode="after")` |
| Serializer | `@field_serializer("field")` |
| Computed | `@computed_field` + `@property` |
| Exclude unset | `model_dump(exclude_unset=True)` |
| Discriminator | `Field(discriminator="type")` |
| Validation | Usage |
|------------|-------|
| Required | `name: str` |
| Optional | `name: str \| None = None` |
| Default | `name: str = "default"` |
| Constraints | `Field(min_length=1, max_length=100)` |
| Custom | `@field_validator` |
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |
| using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |
| verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |