Ошибки валидации

Pydantic пытается предоставить полезные ошибки проверки. Ниже приведены сведения о распространенных ошибках проверки, с которыми пользователи могут столкнуться при работе с pydantic, а также некоторые предложения по их исправлению.

тип_аргументов¶

Эта ошибка возникает, когда объект, который будет передан в качестве аргумента функции во время проверки, не является tuple , list или dict . Поскольку NamedTuple в своей реализации использует вызовы функций, это один из способов возникновения этой ошибки:

from typing import NamedTuple

from pydantic import BaseModel, ValidationError


class MyNamedTuple(NamedTuple):
    x: int


class MyModel(BaseModel):
    field: MyNamedTuple


try:
    MyModel.model_validate({'field': 'invalid'})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'arguments_type'

утверждение_ошибка¶

Эта ошибка возникает, когда во время проверки встречается неверный оператор assert :

from pydantic import BaseModel, ValidationError, field_validator


class Model(BaseModel):
    x: int

    @field_validator('x')
    @classmethod
    def force_x_positive(cls, v):
        assert v > 0
        return v


try:
    Model(x=-1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'assertion_error'

`bool_parsing`¶

Эта ошибка возникает, когда входное значение представляет собой строку, которая недопустима для приведения к логическому значению:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: bool


Model(x='true')  # OK

try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bool_parsing'

`bool_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля bool :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: bool


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bool_type'

Эта ошибка также возникает для строгих полей, когда входное значение не является экземпляром bool .

`bytes_too_long`¶

Эта ошибка возникает, когда длина значения в bytes превышает ограничение max_length поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: bytes = Field(max_length=3)


try:
    Model(x=b'test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bytes_too_long'

`bytes_too_short`¶

Эта ошибка возникает, когда длина значения в bytes меньше ограничения min_length поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: bytes = Field(min_length=3)


try:
    Model(x=b't')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bytes_too_short'

байт_тип¶

Эта ошибка возникает, когда тип входного значения недопустим для поля bytes :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: bytes


try:
    Model(x=123)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'bytes_type'

Эта ошибка также возникает для строгих полей, когда входное значение не является экземпляром bytes .

`callable_type`¶

Эта ошибка возникает, когда входное значение недопустимо как Callable :

from typing import Any, Callable

from pydantic import BaseModel, ImportString, ValidationError


class Model(BaseModel):
    x: ImportString[Callable[[Any], Any]]


Model(x='math:cos')  # OK

try:
    Model(x='os.path')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'callable_type'

`dataclass_exact_type`¶

Эта ошибка возникает при проверке класса данных со strict=True , и входные данные не являются экземпляром класса данных:

import pydantic.dataclasses
from pydantic import TypeAdapter, ValidationError


@pydantic.dataclasses.dataclass
class MyDataclass:
    x: str


adapter = TypeAdapter(MyDataclass)

print(adapter.validate_python(MyDataclass(x='test'), strict=True))
#> MyDataclass(x='test')
print(adapter.validate_python({'x': 'test'}))
#> MyDataclass(x='test')

try:
    adapter.validate_python({'x': 'test'}, strict=True)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'dataclass_exact_type'

`dataclass_type`¶

Эта ошибка возникает, когда входное значение недопустимо для поля dataclass :

from pydantic import ValidationError, dataclasses


@dataclasses.dataclass
class Inner:
    x: int


@dataclasses.dataclass
class Outer:
    y: Inner


Outer(y=Inner(x=1))  # OK

try:
    Outer(y=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'dataclass_type'

`date_from_datetime_inexact`¶

Эта ошибка возникает, когда входное значение datetime указанное для поля date , имеет ненулевой компонент времени. Чтобы метка времени могла быть преобразована в поле типа date , все компоненты времени должны быть равны нулю:

from datetime import date, datetime

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: date


Model(x='2023-01-01')  # OK
Model(x=datetime(2023, 1, 1))  # OK

try:
    Model(x=datetime(2023, 1, 1, 12))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_from_datetime_inexact'

`date_from_datetime_parsing`¶

Эта ошибка возникает, когда входное значение представляет собой строку, которую невозможно проанализировать для поля date :

from datetime import date

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: date


try:
    Model(x='XX1494012000')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_from_datetime_parsing'

`date_future`¶

Эта ошибка возникает, когда входное значение, указанное для поля FutureDate , находится не в будущем:

from datetime import date

from pydantic import BaseModel, FutureDate, ValidationError


class Model(BaseModel):
    x: FutureDate


try:
    Model(x=date(2000, 1, 1))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_future'

`date_parsing`¶

Эта ошибка возникает при проверке JSON, где входное значение представляет собой строку, которую невозможно проанализировать для поля date :

import json
from datetime import date

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: date = Field(strict=True)


try:
    Model.model_validate_json(json.dumps({'x': '1'}))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_parsing'

`date_past`¶

Эта ошибка возникает, когда значение, указанное в поле PastDate , не находится в прошлом:

from datetime import date, timedelta

from pydantic import BaseModel, PastDate, ValidationError


class Model(BaseModel):
    x: PastDate


try:
    Model(x=date.today() + timedelta(1))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_past'

`date_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля date :

from datetime import date

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: date


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'date_type'

Эта ошибка также возникает для полей со строгими требованиями, если входное значение не является экземпляром date .

`datetime_from_date_parsing`¶

!!! note Поддержка этой ошибки, а также поддержка анализа даты и времени из дат yyyy-MM-DD будут добавлены в v2.6.0

Эта ошибка возникает, когда входное значение представляет собой строку, которую невозможно проанализировать для поля datetime :

from datetime import datetime

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: datetime


try:
    # there is no 13th month
    Model(x='2023-13-01')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_from_date_parsing'

`datetime_future`¶

Эта ошибка возникает, когда значение, указанное в поле FutureDatetime , не находится в будущем:

from datetime import datetime

from pydantic import BaseModel, FutureDatetime, ValidationError


class Model(BaseModel):
    x: FutureDatetime


try:
    Model(x=datetime(2000, 1, 1))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_future'

`datetime_object_invalid`¶

Эта ошибка возникает, когда что-то в объекте datetime недопустимо:

from datetime import datetime, tzinfo

from pydantic import AwareDatetime, BaseModel, ValidationError


class CustomTz(tzinfo):
    # utcoffset is not implemented!

    def tzname(self, _dt):
        return 'CustomTZ'


class Model(BaseModel):
    x: AwareDatetime


try:
    Model(x=datetime(2023, 1, 1, tzinfo=CustomTz()))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_object_invalid'

`datetime_parsing`¶

Эта ошибка возникает, когда значение представляет собой строку, которую невозможно проанализировать для поля datetime :

import json
from datetime import datetime

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: datetime = Field(strict=True)


try:
    Model.model_validate_json(json.dumps({'x': 'not a datetime'}))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_parsing'

`datetime_past`¶

Эта ошибка возникает, когда значение, указанное в поле PastDatetime , не находится в прошлом:

from datetime import datetime, timedelta

from pydantic import BaseModel, PastDatetime, ValidationError


class Model(BaseModel):
    x: PastDatetime


try:
    Model(x=datetime.now() + timedelta(100))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_past'

`datetime_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля datetime :

from datetime import datetime

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: datetime


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'datetime_type'

Эта ошибка также возникает для строгих полей, когда входное значение не является экземпляром datetime .

`decimal_max_digits`¶

Эта ошибка возникает, когда значение, указанное для Decimal , содержит слишком много цифр:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(max_digits=3)


try:
    Model(x='42.1234')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_max_digits'

`decimal_max_places`¶

Эта ошибка возникает, когда значение, указанное для Decimal имеет слишком много цифр после десятичной точки:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(decimal_places=3)


try:
    Model(x='42.1234')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_max_places'

`decimal_parsing`¶

Эта ошибка возникает, когда значение, указанное для Decimal , не может быть проанализировано как десятичное число:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(decimal_places=3)


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_parsing'

`decimal_type`¶

Эта ошибка возникает, когда значение, указанное для Decimal , имеет неправильный тип:

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(decimal_places=3)


try:
    Model(x=[1, 2, 3])
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_type'

Эта ошибка также возникает для полей со строгими требованиями, если входное значение не является экземпляром Decimal .

`decimal_whole_digits`¶

Эта ошибка возникает, когда значение, указанное для Decimal имеет больше цифр перед десятичной запятой, чем max_digits - decimal_places (если указаны оба):

from decimal import Decimal

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: Decimal = Field(max_digits=6, decimal_places=3)


try:
    Model(x='12345.6')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'decimal_whole_digits'

Эта ошибка также возникает для полей со строгими требованиями, если входное значение не является экземпляром Decimal .

`dict_type`¶

Эта ошибка возникает, когда тип входного значения не является dict для поля dict :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: dict


try:
    Model(x=['1', '2'])
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'dict_type'

`enum`¶

Эта ошибка возникает, когда входное значение не существует в элементах поля enum :

from enum import Enum

from pydantic import BaseModel, ValidationError


class MyEnum(str, Enum):
    option = 'option'


class Model(BaseModel):
    x: MyEnum


try:
    Model(x='other_option')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'enum'

`extra_forbidden`¶

Эта ошибка возникает, когда входное значение содержит дополнительные поля, но model_config['extra'] == 'forbid' :

from pydantic import BaseModel, ConfigDict, ValidationError


class Model(BaseModel):
    x: str

    model_config = ConfigDict(extra='forbid')


try:
    Model(x='test', y='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'extra_forbidden'

Подробнее о extra конфигурации можно прочитать в разделе Дополнительные атрибуты.

`finite_number`¶

Эта ошибка возникает, когда значение бесконечно или слишком велико для представления в виде 64-битного числа с плавающей запятой во время проверки:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


try:
    Model(x=2.2250738585072011e308)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'finite_number'

`float_parsing`¶

Эта ошибка возникает, когда значение представляет собой строку, которую невозможно проанализировать как float :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: float


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'float_parsing'

`float_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля float :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: float


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'float_type'

`frozen_field`¶

Эта ошибка возникает, когда вы пытаетесь присвоить значение полю с frozen=True или удалить такое поле:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: str = Field('test', frozen=True)


model = Model()

try:
    model.x = 'test1'
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_field'

try:
    del model.x
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_field'

`frozen_instance`¶

Эта ошибка возникает, когда model_config['frozen] == True и вы пытаетесь удалить или присвоить новое значение любому из полей:

from pydantic import BaseModel, ConfigDict, ValidationError


class Model(BaseModel):
    x: int

    model_config = ConfigDict(frozen=True)


m = Model(x=1)

try:
    m.x = 2
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_instance'

try:
    del m.x
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_instance'

`frozen_set_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля frozenset :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: frozenset


try:
    model = Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'frozen_set_type'

`get_attribute_error`¶

Эта ошибка возникает, когда model_config['from_attributes'] == True и при чтении атрибутов возникает ошибка:

from pydantic import BaseModel, ConfigDict, ValidationError


class Foobar:
    def __init__(self):
        self.x = 1

    @property
    def y(self):
        raise RuntimeError('intentional error')


class Model(BaseModel):
    x: int
    y: str

    model_config = ConfigDict(from_attributes=True)


try:
    Model.model_validate(Foobar())
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'get_attribute_error'

`greater_than`¶

Эта ошибка возникает, когда значение не превышает ограничение gt поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(gt=10)


try:
    Model(x=10)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'greater_than'

`greater_than_equal`¶

Эта ошибка возникает, когда значение не больше или равно ограничению ge поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(ge=10)


try:
    Model(x=9)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'greater_than_equal'

`int_from_float`¶

Эта ошибка возникает, когда вы предоставляете значение float для поля int :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


try:
    Model(x=0.5)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_from_float'

`int_parsing`¶

Эта ошибка возникает, когда значение не может быть проанализировано как int :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_parsing'

`int_parsing_size`¶

Эта ошибка возникает при попытке проанализировать значение Python или JSON из строки, выходящей за пределы максимального диапазона, разрешенного синтаксическим анализом Python str to int :

import json

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


# from Python
assert Model(x='1' * 4_300).x == int('1' * 4_300)  # OK

too_long = '1' * 4_301
try:
    Model(x=too_long)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_parsing_size'

# from JSON
try:
    Model.model_validate_json(json.dumps({'x': too_long}))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_parsing_size'

`int_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля int :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: int


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'int_type'

`invalid_key`¶

Эта ошибка возникает при попытке проверить dict , ключ которого не является экземпляром str :

from pydantic import BaseModel, ConfigDict, ValidationError


class Model(BaseModel):
    x: int

    model_config = ConfigDict(extra='allow')


try:
    Model.model_validate({'x': 1, b'y': 2})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'invalid_key'

`is_instance_of`¶

Эта ошибка возникает, когда входное значение не является экземпляром ожидаемого типа:

from pydantic import BaseModel, ConfigDict, ValidationError


class Nested:
    x: str


class Model(BaseModel):
    y: Nested

    model_config = ConfigDict(arbitrary_types_allowed=True)


try:
    Model(y='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'is_instance_of'

`is_subclass_of`¶

Эта ошибка возникает, когда входное значение не является подклассом ожидаемого типа:

from typing import Type

from pydantic import BaseModel, ValidationError


class Nested:
    x: str


class Model(BaseModel):
    y: Type[Nested]


try:
    Model(y='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'is_subclass_of'

`iterable_type`¶

Эта ошибка возникает, когда входное значение недопустимо как Iterable :

from typing import Iterable

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    y: Iterable


try:
    Model(y=123)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'iterable_type'

`iteration_error`¶

Эта ошибка возникает, когда во время итерации возникает ошибка:

from typing import List

from pydantic import BaseModel, ValidationError


def gen():
    yield 1
    raise RuntimeError('error')


class Model(BaseModel):
    x: List[int]


try:
    Model(x=gen())
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'iteration_error'

`json_invalid`¶

Эта ошибка возникает, когда входное значение не является допустимой строкой JSON:

from pydantic import BaseModel, Json, ValidationError


class Model(BaseModel):
    x: Json


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'json_invalid'

`json_type`¶

Эта ошибка возникает, когда входное значение имеет тип, который невозможно проанализировать как JSON:

from pydantic import BaseModel, Json, ValidationError


class Model(BaseModel):
    x: Json


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'json_type'

`less_than`¶

Эта ошибка возникает, когда входное значение не меньше ограничения lt поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(lt=10)


try:
    Model(x=10)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'less_than'

`less_than_equal`¶

Эта ошибка возникает, когда входное значение не меньше или равно ограничению le поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(le=10)


try:
    Model(x=11)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'less_than_equal'

`list_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля list :

from typing import List

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: List[int]


try:
    Model(x=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'list_type'

`literal_error`¶

Эта ошибка возникает, когда входное значение не является одним из ожидаемых литеральных значений:

from typing_extensions import Literal

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: Literal['a', 'b']


Model(x='a')  # OK

try:
    Model(x='c')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'literal_error'

`mapping_type`¶

Эта ошибка возникает, когда во время проверки возникает проблема из-за сбоя вызова методов протокола Mapping , таких как .items() :

from collections.abc import Mapping
from typing import Dict

from pydantic import BaseModel, ValidationError


class BadMapping(Mapping):
    def items(self):
        raise ValueError()

    def __iter__(self):
        raise ValueError()

    def __getitem__(self, key):
        raise ValueError()

    def __len__(self):
        return 1


class Model(BaseModel):
    x: Dict[str, str]


try:
    Model(x=BadMapping())
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'mapping_type'

`missing`¶

Эта ошибка возникает, когда во входном значении отсутствуют обязательные поля:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: str


try:
    Model()
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'missing'

`missing_argument`¶

Эта ошибка возникает, когда необходимый аргумент позиционного или ключевого слова не передается функции, украшенной validate_call :

from pydantic import ValidationError, validate_call


@validate_call
def foo(a: int):
    return a


try:
    foo()
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'missing_argument'

`missing_keyword_only_argument`¶

Эта ошибка возникает, когда обязательный аргумент, содержащий только ключевое слово, не передается функции, украшенной validate_call :

from pydantic import ValidationError, validate_call


@validate_call
def foo(*, a: int):
    return a


try:
    foo()
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'missing_keyword_only_argument'

`missing_positional_only_argument`¶

Эта ошибка возникает, когда обязательный позиционный аргумент не передается функции, украшенной validate_call :

from pydantic import ValidationError, validate_call


@validate_call
def foo(a: int, /):
    return a


try:
    foo()
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'missing_positional_only_argument'

`model_attributes_type`¶

Эта ошибка возникает, когда входное значение не является допустимым словарем, экземпляром модели или экземпляром, из которого можно извлечь поля:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    a: int
    b: int


# simply validating a dict
print(Model.model_validate({'a': 1, 'b': 2}))
#> a=1 b=2


class CustomObj:
    def __init__(self, a, b):
        self.a = a
        self.b = b


# using from attributes to extract fields from an objects
print(Model.model_validate(CustomObj(3, 4), from_attributes=True))
#> a=3 b=4

try:
    Model.model_validate('not an object', from_attributes=True)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'model_attributes_type'

`model_type`¶

Эта ошибка возникает, когда входные данные модели не являются экземпляром модели или словаря:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    a: int
    b: int


# simply validating a dict
m = Model.model_validate({'a': 1, 'b': 2})
print(m)
#> a=1 b=2

# validating an existing model instance
print(Model.model_validate(m))
#> a=1 b=2

try:
    Model.model_validate('not an object')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'model_type'

`multiple_argument_values`¶

Эта ошибка возникает, когда вы предоставляете несколько значений для одного аргумента при вызове функции, украшенной validate_call :

from pydantic import ValidationError, validate_call


@validate_call
def foo(a: int):
    return a


try:
    foo(1, a=2)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'multiple_argument_values'

`multiple_of`¶

Эта ошибка возникает, когда входные данные не кратны ограничению multiple_of поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: int = Field(multiple_of=5)


try:
    Model(x=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'multiple_of'

`no_such_attribute`¶

Эта ошибка возникает, когда validate_assignment=True в конфигурации, и вы пытаетесь присвоить значение атрибуту, который не является существующим полем:

from pydantic import ConfigDict, ValidationError, dataclasses


@dataclasses.dataclass(config=ConfigDict(validate_assignment=True))
class MyDataclass:
    x: int


m = MyDataclass(x=1)
try:
    m.y = 10
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'no_such_attribute'

`none_required`¶

Эта ошибка возникает, когда входное значение не равно None для поля, для которого требуется None :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: None


try:
    Model(x=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'none_required'

!!! note Примечание. Эта ошибка может возникнуть, если в вашей модели существует конфликт имен между именем поля и его типом. Более конкретно, эта ошибка, скорее всего, возникнет, если значением по умолчанию для этого поля является None .

For example, the following would yield the `none_required` validation error since the field `int` is set to a default value of `None` and has the exact same name as its type, which causes problems with validation.
```py
from typing import Optional

from pydantic import BaseModel


class M1(BaseModel):
    int: Optional[int] = None


m = M1(int=123)  # errors
```

`recursion_loop`¶

Эта ошибка возникает при обнаружении циклической ссылки:

from typing import List

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: List['Model']


d = {'x': []}
d['x'].append(d)
try:
    Model(**d)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'recursion_loop'

`set_type`¶

Эта ошибка возникает, когда тип значения недопустим для set поля:

from typing import Set

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: Set[int]


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'set_type'

`string_pattern_mismatch`¶

Эта ошибка возникает, когда входное значение не соответствует ограничению pattern поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: str = Field(pattern='test')


try:
    Model(x='1')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_pattern_mismatch'

`string_sub_type`¶

Эта ошибка возникает, когда значение является экземпляром строгого подтипа str , когда поле является строгим:

from enum import Enum

from pydantic import BaseModel, Field, ValidationError


class MyEnum(str, Enum):
    foo = 'foo'


class Model(BaseModel):
    x: str = Field(strict=True)


try:
    Model(x=MyEnum.foo)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_sub_type'

`string_too_long`¶

Эта ошибка возникает, когда входное значение представляет собой строку, длина которой превышает ограничение max_length поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: str = Field(max_length=3)


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_too_long'

`string_too_short`¶

Эта ошибка возникает, когда входное значение представляет собой строку, длина которой меньше ограничения min_length поля:

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: str = Field(min_length=3)


try:
    Model(x='t')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_too_short'

`string_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля str :

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: str


try:
    Model(x=1)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_type'

Эта ошибка также возникает для полей со строгими требованиями, если входное значение не является экземпляром str .

`string_unicode`¶

Эта ошибка возникает, когда значение невозможно проанализировать как строку Юникода:

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: str


try:
    Model(x=b'\x81')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'string_unicode'

`time_delta_parsing`¶

Эта ошибка возникает, когда входное значение представляет собой строку, которую невозможно проанализировать для поля timedelta :

from datetime import timedelta

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: timedelta


try:
    Model(x='t')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'time_delta_parsing'

`time_delta_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля timedelta :

from datetime import timedelta

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: timedelta


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'time_delta_type'

Эта ошибка также возникает для строгих полей, когда входное значение не является экземпляром timedelta .

`time_parsing`¶

Эта ошибка возникает, когда входное значение представляет собой строку, которую невозможно проанализировать для поля time :

from datetime import time

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: time


try:
    Model(x='25:20:30.400')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'time_parsing'

`time_type`¶

Эта ошибка возникает, когда тип значения недопустим для поля time :

from datetime import time

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: time


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'time_type'

Эта ошибка также возникает для строгих полей, когда входное значение не является экземпляром time .

`timezone_aware`¶

Эта ошибка возникает, когда значение datetime , указанное для поля datetime с учетом часового пояса, не содержит информации о часовом поясе:

from datetime import datetime

from pydantic import AwareDatetime, BaseModel, ValidationError


class Model(BaseModel):
    x: AwareDatetime


try:
    Model(x=datetime.now())
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'timezone_aware'

`timezone_naive`¶

Эта ошибка возникает, когда значение datetime указанное для поля datetime пояса, содержит информацию о часовом поясе:

from datetime import datetime, timezone

from pydantic import BaseModel, NaiveDatetime, ValidationError


class Model(BaseModel):
    x: NaiveDatetime


try:
    Model(x=datetime.now(tz=timezone.utc))
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'timezone_naive'

`too_long`¶

Эта ошибка возникает, когда длина входного значения превышает ограничение max_length поля:

from typing import List

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: List[int] = Field(max_length=3)


try:
    Model(x=[1, 2, 3, 4])
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'too_long'

`too_short`¶

Эта ошибка возникает, когда длина значения меньше ограничения min_length поля:

from typing import List

from pydantic import BaseModel, Field, ValidationError


class Model(BaseModel):
    x: List[int] = Field(min_length=3)


try:
    Model(x=[1, 2])
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'too_short'

`tuple_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля tuple :

from typing import Tuple

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: Tuple[int]


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'tuple_type'

Эта ошибка также возникает для строгих полей, когда входное значение не является экземпляром tuple .

`unexpected_keyword_argument`¶

Эта ошибка возникает, когда вы указываете значение по ключевому слову для позиционного аргумента при вызове функции, украшенной validate_call :

from pydantic import ValidationError, validate_call


@validate_call
def foo(a: int, /):
    return a


try:
    foo(a=2)
except ValidationError as exc:
    print(repr(exc.errors()[1]['type']))
    #> 'unexpected_keyword_argument'

Он также возникает при использовании pydantic.dataclasses и extra=forbid :

from pydantic import TypeAdapter, ValidationError
from pydantic.dataclasses import dataclass


@dataclass(config={'extra': 'forbid'})
class Foo:
    bar: int


try:
    TypeAdapter(Foo).validate_python({'bar': 1, 'foobar': 2})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'unexpected_keyword_argument'

`unexpected_positional_argument`¶

Эта ошибка возникает, когда вы предоставляете позиционное значение для аргумента, содержащего только ключевые слова, при вызове функции, украшенной validate_call :

from pydantic import ValidationError, validate_call


@validate_call
def foo(*, a: int):
    return a


try:
    foo(2)
except ValidationError as exc:
    print(repr(exc.errors()[1]['type']))
    #> 'unexpected_positional_argument'

`union_tag_invalid`¶

Эта ошибка возникает, когда дискриминатор входных данных не является одним из ожидаемых значений:

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, Field, ValidationError


class BlackCat(BaseModel):
    pet_type: Literal['blackcat']


class WhiteCat(BaseModel):
    pet_type: Literal['whitecat']


class Model(BaseModel):
    cat: Union[BlackCat, WhiteCat] = Field(..., discriminator='pet_type')


try:
    Model(cat={'pet_type': 'dog'})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'union_tag_invalid'

`union_tag_not_found`¶

Эта ошибка возникает, когда невозможно извлечь значение дискриминатора из входных данных:

from typing import Union

from typing_extensions import Literal

from pydantic import BaseModel, Field, ValidationError


class BlackCat(BaseModel):
    pet_type: Literal['blackcat']


class WhiteCat(BaseModel):
    pet_type: Literal['whitecat']


class Model(BaseModel):
    cat: Union[BlackCat, WhiteCat] = Field(..., discriminator='pet_type')


try:
    Model(cat={'name': 'blackcat'})
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'union_tag_not_found'

`url_parsing`¶

Эта ошибка возникает, когда входное значение невозможно проанализировать как URL-адрес:

from pydantic import AnyUrl, BaseModel, ValidationError


class Model(BaseModel):
    x: AnyUrl


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_parsing'

`url_scheme`¶

Эта ошибка возникает, когда схема URL-адреса недействительна для типа URL-адреса поля:

from pydantic import BaseModel, HttpUrl, ValidationError


class Model(BaseModel):
    x: HttpUrl


try:
    Model(x='ftp://example.com')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_scheme'

`url_syntax_violation`¶

Эта ошибка возникает, если синтаксис URL-адреса недействителен:

from pydantic import BaseModel, Field, HttpUrl, ValidationError


class Model(BaseModel):
    x: HttpUrl = Field(strict=True)


try:
    Model(x='http:////example.com')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_syntax_violation'

`url_too_long`¶

Эта ошибка возникает, когда длина URL-адреса превышает 2083:

from pydantic import BaseModel, HttpUrl, ValidationError


class Model(BaseModel):
    x: HttpUrl


try:
    Model(x='x' * 2084)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_too_long'

`url_type`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля URL:

from pydantic import BaseModel, HttpUrl, ValidationError


class Model(BaseModel):
    x: HttpUrl


try:
    Model(x=None)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'url_type'

`uuid_parsing`¶

Эта ошибка возникает, когда тип входного значения недопустим для поля UUID:

from uuid import UUID

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    u: UUID


try:
    Model(u='12345678-124-1234-1234-567812345678')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'uuid_parsing'

`uuid_type`¶

Эта ошибка возникает, когда тип входного значения не является допустимым экземпляром для поля UUID (str, bytes или UUID):

from uuid import UUID

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    u: UUID


try:
    Model(u=1234567812412341234567812345678)
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'uuid_type'

`uuid_version`¶

Эта ошибка возникает, когда тип входного значения не соответствует версии UUID:

from pydantic import UUID5, BaseModel, ValidationError


class Model(BaseModel):
    u: UUID5


try:
    Model(u='a6cc5730-2261-11ee-9c43-2eb5a363657c')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'uuid_version'

`value_error`¶

Эта ошибка возникает, когда во время проверки возникает ValueError :

from pydantic import BaseModel, ValidationError, field_validator


class Model(BaseModel):
    x: str

    @field_validator('x')
    @classmethod
    def repeat_b(cls, v):
        raise ValueError()


try:
    Model(x='test')
except ValidationError as exc:
    print(repr(exc.errors()[0]['type']))
    #> 'value_error'

本文总阅读量次

Ошибки валидации

тип_аргументов¶

утверждение_ошибка¶

bool_parsing¶

bool_type¶

bytes_too_long¶

bytes_too_short¶

байт_тип¶

callable_type¶

dataclass_exact_type¶

dataclass_type¶

date_from_datetime_inexact¶

date_from_datetime_parsing¶

date_future¶

date_parsing¶

date_past¶

date_type¶

datetime_from_date_parsing¶

datetime_future¶

datetime_object_invalid¶

datetime_parsing¶

datetime_past¶

datetime_type¶

decimal_max_digits¶

decimal_max_places¶

decimal_parsing¶

decimal_type¶

decimal_whole_digits¶

dict_type¶

enum¶

extra_forbidden¶

finite_number¶

float_parsing¶

float_type¶

frozen_field¶

frozen_instance¶

frozen_set_type¶

get_attribute_error¶

greater_than¶

greater_than_equal¶

int_from_float¶

int_parsing¶

int_parsing_size¶

int_type¶

invalid_key¶

is_instance_of¶

is_subclass_of¶

iterable_type¶

iteration_error¶

json_invalid¶

json_type¶

less_than¶

less_than_equal¶

list_type¶

literal_error¶

mapping_type¶

missing¶

missing_argument¶

missing_keyword_only_argument¶

missing_positional_only_argument¶

model_attributes_type¶

model_type¶

multiple_argument_values¶

multiple_of¶

no_such_attribute¶

none_required¶

recursion_loop¶

set_type¶

string_pattern_mismatch¶

string_sub_type¶

string_too_long¶

string_too_short¶

string_type¶

string_unicode¶

time_delta_parsing¶

time_delta_type¶

time_parsing¶

time_type¶

timezone_aware¶

timezone_naive¶