Какие данные анализирует Pydantic?

Pydantic: анализ и валидация данных

Pydantic — это библиотека для валидации данных и анализа типов в Python. Она автоматически проверяет и преобразует данные в соответствии с определёнными схемами.

Что анализирует Pydantic?

Основные задачи Pydantic:

1. Валидация типов — проверяет, что данные имеют правильный тип
2. Преобразование типов — конвертирует данные в нужный формат
3. Анализ структуры — проверяет, что все требуемые поля присутствуют
4. Кастомная валидация — применяет пользовательские правила проверки

Простой пример

from pydantic import BaseModel, ValidationError

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

# Валидные данные
user = User(name="Alice", age=30, email="alice@example.com")
print(user)  # name='Alice' age=30 email='alice@example.com'

# Невалидные данные
try:
    user = User(name="Bob", age="not a number", email="bob@example.com")
except ValidationError as e:
    print(e)  # age: Input should be a valid integer

Автоматическое преобразование типов

Pydantic попытается конвертировать данные в нужный тип:

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    quantity: int

# Передаём строки, Pydantic преобразует в числа
product = Product(
    name="Laptop",
    price="999.99",  # строка → float
    quantity="5"     # строка → int
)
print(product.price)     # 999.99 (тип: float)
print(product.quantity)  # 5 (тип: int)

Анализ структуры данных

Pydantic проверяет, что все требуемые поля присутствуют:

from pydantic import BaseModel

class Order(BaseModel):
    order_id: int
    user_id: int
    status: str

# Хорошо — все поля
order = Order(order_id=1, user_id=100, status="pending")

# Плохо — пропущено поле
try:
    order = Order(order_id=1, user_id=100)  # status отсутствует
except ValidationError as e:
    print(e)  # status: Field required

Опциональные поля

Анализ опциональных полей с помощью Optional или дефолтных значений:

from pydantic import BaseModel
from typing import Optional

class Account(BaseModel):
    username: str
    password: str
    phone: Optional[str] = None  # Опционально
    notifications_enabled: bool = True  # Дефолт True

# Работает без phone
account1 = Account(username="alice", password="secret")
print(account1.phone)  # None
print(account1.notifications_enabled)  # True

# Работает с phone
account2 = Account(
    username="bob",
    password="secret",
    phone="+1234567890"
)
print(account2.phone)  # +1234567890

Кастомная валидация

Пользовательские правила проверки данных:

from pydantic import BaseModel, field_validator

class Person(BaseModel):
    name: str
    age: int
    email: str
    
    @field_validator('age')
    @classmethod
    def age_must_be_positive(cls, v):
        if v <= 0:
            raise ValueError('Age must be positive')
        if v > 150:
            raise ValueError('Age seems unrealistic')
        return v
    
    @field_validator('email')
    @classmethod
    def email_must_be_valid(cls, v):
        if '@' not in v:
            raise ValueError('Invalid email format')
        return v

person = Person(name="Alice", age=25, email="alice@example.com")
try:
    person = Person(name="Bob", age=-5, email="bob@example")  # Ошибка
except ValidationError as e:
    print(e)

Анализ вложенных структур

Pydantic анализирует сложные вложенные данные:

from pydantic import BaseModel
from typing import List

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

class Person(BaseModel):
    name: str
    age: int
    address: Address  # Вложенная модель
    hobbies: List[str]  # Список строк

person = Person(
    name="Alice",
    age=30,
    address={
        "street": "123 Main St",
        "city": "New York",
        "postal_code": "10001"
    },
    hobbies=["reading", "coding", "hiking"]
)
print(person.address.city)  # New York
print(person.hobbies[0])   # reading

Анализ JSON Schema

Pydantic может генерировать JSON Schema для документации:

from pydantic import BaseModel
import json

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

# Генерируем JSON Schema
schema = User.model_json_schema()
print(json.dumps(schema, indent=2))
"""
{
  "properties": {
    "name": {"type": "string"},
    "age": {"type": "integer"},
    "email": {"type": "string"}
  },
  "required": ["name", "age", "email"],
  "type": "object"
}
"""

Анализ данных с Config

Пользовательская конфигурация для анализа данных:

from pydantic import BaseModel, ConfigDict

class Settings(BaseModel):
    model_config = ConfigDict(
        str_strip_whitespace=True,  # Убирает пробелы в строках
        validate_default=True,       # Валидирует дефолтные значения
        extra='forbid'               # Запрещает неизвестные поля
    )
    
    api_key: str
    debug: bool = False

# Работает
settings = Settings(api_key=" secret ", debug=True)
print(f"'{settings.api_key}'")
# 'secret' (пробелы убраны благодаря str_strip_whitespace)

# Ошибка — неизвестное поле
try:
    settings = Settings(api_key="secret", unknown_field="value")
except ValidationError as e:
    print(e)  # Extra inputs are not permitted

Практический пример: API endpoint

Pydantic часто используется в FastAPI для анализа запросов:

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()

class UserCreate(BaseModel):
    username: str
    email: EmailStr  # Специальный тип для email
    age: int

@app.post("/users")
async def create_user(user: UserCreate):
    # Pydantic уже валидировал и преобразовал данные
    return {"username": user.username, "email": user.email}

# Если клиент отправит неправильные данные, Pydantic вернёт 422 Unprocessable Entity

Выводы

Pydantic анализирует:

• Типы данных — проверяет и преобразует
• Структуру — требуемые и опциональные поля
• Формат — email, URL, числа, даты
• Кастомные правила — пользовательская валидация
• Вложенные данные — сложные структуры
• JSON Schema — автоматическая документация

Pydantic делает обработку данных безопасной и предсказуемой, предотвращая ошибки на ранних этапах.