pydantic接口定义检查（一）

from pydantic import BaseModel

class User(BaseModel):
    id: int
     name: str = 'John Doe'  # name是字符型，同时设定了一个默认值

# 情况一：因为定义了User类中id是数字，所以这里实例化后，如果可以变成数字的，直接转化
user = User(id='123')
>>> '{"id": 123, "name": "Jane Doe"}'

# 情况二：定义id为整数，且不可以转化为整数，则会如上报错
user = User(id='123a')
>>> ValidationError: 1 validation error for User
id
  value is not a valid integer (type=type_error.integer)

# 情况三：定义id为整数，此时是float格式，也会报错
user = User(id='123.2')
>>> ValidationError: 1 validation error for User
id
  value is not a valid integer (type=type_error.integer)

from pydantic import ValidationError

# 这里规定了id必须是int类型
class User(BaseModel):
    id: int
    name: str = 'John Doe'
    signup_ts: datetime | None # 字符型或者None都是可以的
    tastes: dict[str, PositiveInt] # 字典型，规定key是字符型，value一定是正整数型
    address: Optional[Address] # Optional可选是否填写
    bool_value: bool 
    # 正负取值，print(BooleanModel(bool_value='False'))

# 然而这里id给了个str类型
external_data = {'id': 'not an int', 'tastes': {}}  

try:
    User(**external_data)  
except ValidationError as e:
    print(e.errors())

from typing import Deque, List, Optional, Tuple

from pydantic import BaseModel


class Model(BaseModel):
    simple_list: Optional[list] = None
    list_of_ints: Optional[List[int]] = None

    simple_tuple: Optional[tuple] = None
    tuple_of_different_types: Optional[Tuple[int, float, bool]] = None

    deque: Optional[Deque[int]] = None


print(Model(simple_list=['1', '2', '3']).simple_list)
#> ['1', '2', '3']
print(Model(list_of_ints=['1', '2', '3']).list_of_ints)
#> [1, 2, 3]

print(Model(simple_tuple=[1, 2, 3, 4]).simple_tuple)
#> (1, 2, 3, 4)
print(Model(tuple_of_different_types=[3, 2, 1]).tuple_of_different_types)
#> (3, 2.0, True)

print(Model(deque=[1, 2, 3]).deque)
#> deque([1, 2, 3])

from typing import Annotated, Dict, List, Literal, Tuple

from annotated_types import Gt

from pydantic import BaseModel


class Fruit(BaseModel):
    name: str  
    color: Literal['red', 'green']   
    # 规定color是字符型，同时只能在red / green两个文本中进行选择
    
    weight: Annotated[float, Gt(0)]  
    
    bazam: Dict[str, List[Tuple[int, bool, float]]]   
    # 定义bazam为字符型，key为str型，value为List型，这里的嵌套结构比较多


print(
    Fruit(
        name='Apple',
        color='red',
        weight=4.2,
        bazam={'foobar': [(1, True, 0.1)]},
    )
)

from pydantic import BaseModel, ValidationError, validator


class UserModel(BaseModel):
    # 先规定UserModel必要的几个参数
    name: str
    username: str
    password1: str
    password2: str

	# 然后校验不同参数，validator()第一个参数name
    @validator('name')
    def name_must_contain_space(cls, v):
        if ' ' not in v:
            raise ValueError('must contain a space')
        return v.title()

    @validator('password2')
    def passwords_match(cls, v, values, **kwargs):
        if 'password1' in values and v != values['password1']:
            raise ValueError('passwords do not match')
        return v

    @validator('username')
    def username_alphanumeric(cls, v):
        assert v.isalnum(), 'must be alphanumeric'
        return v


user = UserModel(
    name='samuel colvin',
    username='scolvin',
    password1='zxcvbn',
    password2='zxcvbn',
)
print(user)
#> name='Samuel Colvin' username='scolvin' password1='zxcvbn' password2='zxcvbn'

try:
    UserModel(
        name='samuel',
        username='scolvin',
        password1='zxcvbn',
        password2='zxcvbn2',
    )
except ValidationError as e:
    print(e)

import re
from pydantic import BaseModel, validator, ValidationError
from typing import Optional


class Address(BaseModel):
    street: str
    number: int
    zipcode: str


class Person(BaseModel):
    first_name: str
    last_name: str
    cell_phone_number: str
    address: Optional[Address]

    @validator("cell_phone_number")
    def validate_cell_phone_number(cls, v):
        match = re.match(r"^135\d{8}$", v)
        if len(v) != 11:
            raise ValueError("cell phone number must be 11 digits")
        elif match is None:
            raise ValueError("cell phone number must start with 135")
        return v

from typing import Any, List

from typing_extensions import Annotated

from pydantic import BaseModel, ValidationError
from pydantic.functional_validators import AfterValidator


def check_squares(v: int) -> int:
    assert v**0.5 % 1 == 0, f'{v} is not a square number'
    return v


def double(v: Any) -> Any:
    return v * 2

# 核心在Annotated这个函数
MyNumber = Annotated[int, AfterValidator(double), AfterValidator(check_squares)]


class DemoModel(BaseModel):
    number: List[MyNumber]


print(DemoModel(number=[2, 8]))
#> number=[4, 16]
try:
    DemoModel(number=[2, 4])
except ValidationError as e:
    print(e)
    """
    1 validation error for DemoModel
    number.1
      Assertion failed, 8 is not a square number
    assert ((8 ** 0.5) % 1) == 0 [type=assertion_error, input_value=4, input_type=int]
    """

Annotated[int, AfterValidator(double), AfterValidator(check_squares)]